tweaks

nicer colors
fix wrong code for signed word >= 0
2026-10-22 20:02:27 +00:00 · 2022-07-17 22:09:56 +02:00 · 2022-07-17 21:37:15 +02:00 · 2022-07-17 19:02:56 +02:00 · 2022-07-17 18:59:52 +02:00 · 2022-07-17 12:56:22 +02:00
246 changed files with 11820 additions and 6852 deletions
@@ -1,15 +1,15 @@
 <component name="libraryTable">
  <library name="antlr.antlr4" type="repository">
-    <properties maven-id="org.antlr:antlr4:4.9.3">
+    <properties maven-id="org.antlr:antlr4:4.10.1">
      <exclude>
        <dependency maven-id="com.ibm.icu:icu4j" />
      </exclude>
    </properties>
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.9.3/antlr4-4.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.9.3/antlr4-runtime-4.9.3.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.2/antlr-runtime-3.5.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.1/ST4-4.3.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4/4.10.1/antlr4-4.10.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr4-runtime/4.10.1/antlr4-runtime-4.10.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/antlr-runtime/3.5.3/antlr-runtime-3.5.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/antlr/ST4/4.3.3/ST4-4.3.3.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/abego/treelayout/org.abego.treelayout.core/1.0.3/org.abego.treelayout.core-1.0.3.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/glassfish/javax.json/1.0.4/javax.json-1.0.4.jar!/" />
    </CLASSES>
@@ -1,21 +1,21 @@
 <component name="libraryTable">
  <library name="io.kotest.assertions.core.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.1.0" />
+    <properties maven-id="io.kotest:kotest-assertions-core-jvm:5.3.2" />
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.1.0/kotest-assertions-core-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.3.2/kotest-assertions-core-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.21/kotlin-stdlib-jdk7-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
@@ -1,22 +1,22 @@
 <component name="libraryTable">
  <library name="io.kotest.property.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-property-jvm:5.1.0" />
+    <properties maven-id="io.kotest:kotest-property-jvm:5.3.2" />
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.1.0/kotest-property-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-property-jvm/5.3.2/kotest-property-jvm-5.3.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/com/github/curious-odd-man/rgxgen/1.3/rgxgen-1.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.21/kotlin-stdlib-jdk7-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
@@ -1,39 +1,39 @@
 <component name="libraryTable">
  <library name="io.kotest.runner.junit5.jvm" type="repository">
-    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.1.0" />
+    <properties maven-id="io.kotest:kotest-runner-junit5-jvm:5.3.2" />
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.1.0/kotest-runner-junit5-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.1.0/kotest-framework-api-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.6.0/kotlinx-coroutines-test-jvm-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.1.0/kotest-assertions-shared-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-runner-junit5-jvm/5.3.2/kotest-runner-junit5-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-api-jvm/5.3.2/kotest-framework-api-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-shared-jvm/5.3.2/kotest-assertions-shared-jvm-5.3.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/io/github/java-diff-utils/java-diff-utils/4.11/java-diff-utils-4.11.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.1.0/kotest-common-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.1.0/kotest-framework-engine-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.138/classgraph-4.8.138.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-test-jvm/1.6.1/kotlinx-coroutines-test-jvm-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-common-jvm/5.3.2/kotest-common-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-engine-jvm/5.3.2/kotest-framework-engine-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/github/classgraph/classgraph/4.8.146/classgraph-4.8.146.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/mordant/1.2.1/mordant-1.2.1.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/com/github/ajalt/colormath/1.2.0/colormath-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.6.0/kotlinx-coroutines-debug-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-debug/1.6.1/kotlinx-coroutines-debug-1.6.1.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna/5.9.0/jna-5.9.0.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/net/java/dev/jna/jna-platform/5.9.0/jna-platform-5.9.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/opentest4j/opentest4j/1.2.0/opentest4j-1.2.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.1.0/kotest-framework-discovery-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.1.0/kotest-assertions-core-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.0/kotlinx-coroutines-jdk8-1.6.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.1.0/kotest-assertions-api-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.1.0/kotest-extensions-jvm-5.1.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-discovery-jvm/5.3.2/kotest-framework-discovery-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-core-jvm/5.3.2/kotest-assertions-core-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-jdk8/1.6.1/kotlinx-coroutines-jdk8-1.6.1.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-assertions-api-jvm/5.3.2/kotest-assertions-api-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-extensions-jvm/5.3.2/kotest-extensions-jvm-5.3.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/commons-io/commons-io/2.11.0/commons-io-2.11.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk/1.12.2/mockk-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.12.2/mockk-dsl-jvm-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl/1.12.2/mockk-dsl-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-common/1.12.2/mockk-common-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.12.2/mockk-agent-jvm-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api/1.12.2/mockk-agent-api-1.12.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-common/1.12.2/mockk-agent-common-1.12.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk/1.12.3/mockk-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-common/1.12.3/mockk-common-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl/1.12.3/mockk-dsl-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-dsl-jvm/1.12.3/mockk-dsl-jvm-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-jvm/1.12.3/mockk-agent-jvm-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-api/1.12.3/mockk-agent-api-1.12.3.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/mockk/mockk-agent-common/1.12.3/mockk-agent-common-1.12.3.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/objenesis/objenesis/3.1/objenesis-3.1.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.12.5/byte-buddy-1.12.5.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.12.5/byte-buddy-agent-1.12.5.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.1.0/kotest-framework-concurrency-jvm-5.1.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.0/kotlinx-coroutines-core-jvm-1.6.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy/1.12.6/byte-buddy-1.12.6.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/net/bytebuddy/byte-buddy-agent/1.12.6/byte-buddy-agent-1.12.6.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/io/kotest/kotest-framework-concurrency-jvm/5.3.2/kotest-framework-concurrency-jvm-5.3.2.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlinx/kotlinx-coroutines-core-jvm/1.6.1/kotlinx-coroutines-core-jvm-1.6.1.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.0/kotlin-stdlib-common-1.6.0.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-engine/1.7.2/junit-platform-engine-1.7.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/apiguardian/apiguardian-api/1.1.0/apiguardian-api-1.1.0.jar!/" />
@@ -41,11 +41,11 @@
      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-suite-api/1.7.2/junit-platform-suite-api-1.7.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/junit/platform/junit-platform-launcher/1.7.2/junit-platform-launcher-1.7.2.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/junit/jupiter/junit-jupiter-api/5.7.2/junit-jupiter-api-5.7.2.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.21/kotlin-stdlib-jdk8-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.21/kotlin-stdlib-1.6.21.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.10/kotlin-reflect-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.21/kotlin-stdlib-jdk7-1.6.21.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-reflect/1.6.21/kotlin-reflect-1.6.21.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
@@ -1,13 +1,13 @@
 <component name="libraryTable">
  <library name="michael.bull.kotlin.result.jvm" type="repository">
-    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14" />
+    <properties maven-id="com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16" />
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/1.1.14/kotlin-result-jvm-1.1.14.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.10/kotlin-stdlib-jdk8-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.10/kotlin-stdlib-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/michael-bull/kotlin-result/kotlin-result-jvm/1.1.16/kotlin-result-jvm-1.1.16.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.20/kotlin-stdlib-common-1.6.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk8/1.6.20/kotlin-stdlib-jdk8-1.6.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib/1.6.20/kotlin-stdlib-1.6.20.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/annotations/13.0/annotations-13.0.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.10/kotlin-stdlib-jdk7-1.6.10.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-common/1.6.10/kotlin-stdlib-common-1.6.10.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/jetbrains/kotlin/kotlin-stdlib-jdk7/1.6.20/kotlin-stdlib-jdk7-1.6.20.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
@@ -1,11 +1,15 @@
 <component name="libraryTable">
  <library name="takes" type="repository">
-    <properties maven-id="org.takes:takes:1.19" />
+    <properties maven-id="org.takes:takes:1.20" />
    <CLASSES>
-      <root url="jar://$MAVEN_REPOSITORY$/org/takes/takes/1.19/takes-1.19.jar!/" />
-      <root url="jar://$MAVEN_REPOSITORY$/org/cactoos/cactoos/0.42/cactoos-0.42.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/takes/takes/1.20/takes-1.20.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/cactoos/cactoos/0.50/cactoos-0.50.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/javax/xml/bind/jaxb-api/2.3.0/jaxb-api-2.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/org/slf4j/slf4j-api/1.7.25/slf4j-api-1.7.25.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/apache/commons/commons-text/1.4/commons-text-1.4.jar!/" />
      <root url="jar://$MAVEN_REPOSITORY$/org/apache/commons/commons-lang3/3.7/commons-lang3-3.7.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-core/2.3.0/jaxb-core-2.3.0.jar!/" />
+      <root url="jar://$MAVEN_REPOSITORY$/com/sun/xml/bind/jaxb-impl/2.3.0/jaxb-impl-2.3.0.jar!/" />
    </CLASSES>
    <JAVADOC />
    <SOURCES />
@@ -1,6 +1,9 @@

-This sofware license is for Prog8 the compiler + associated libraries.
-The software generated by running the compiler is excluded from this.
+This sofware license is for Prog8 the compiler + associated library files.
+
+Exception: All output files generated by the compiler (intermediary files
+and compiled binary programs) are excluded from this; you can do with those
+whatever you want.



@@ -16,10 +16,11 @@ https://prog8.readthedocs.io/

 Software license
 ----------------
-GNU GPL 3.0, see file LICENSE
+GNU GPL 3.0 (see file LICENSE), with exception for generated code:

- prog8 (the compiler + libraries) is licensed under GNU GPL 3.0
- *exception:* the resulting files created by running the compiler are free to use in whatever way desired.
+- The compiler and its libraries are free to use according to the terms of the GNU GPL 3.0
+- *exception:* the resulting files (intermediate source codes and resulting binary program) created by the compiler
+  are excluded from the GPL and are free to use in whatever way desired, commercially or not.


 What does Prog8 provide?
@@ -40,6 +40,20 @@ class SymbolTable : StNode("", StNodeType.GLOBAL, Position.DUMMY) {
        vars
    }

+    val allMemMappedVariables: Collection<StMemVar> by lazy {
+        val vars = mutableListOf<StMemVar>()
+        fun collect(node: StNode) {
+            for(child in node.children) {
+                if(child.value.type== StNodeType.MEMVAR)
+                    vars.add(child.value as StMemVar)
+                else
+                    collect(child.value)
+            }
+        }
+        collect(this)
+        vars
+    }
+
    override fun lookup(scopedName: List<String>) = flat[scopedName]
 }

@@ -186,7 +200,11 @@ class StConstant(name: String, val dt: DataType, val value: Double, position: Po
 }


-class StMemVar(name: String, val dt: DataType, val address: UInt, position: Position) :
+class StMemVar(name: String,
+               val dt: DataType,
+               val address: UInt,
+               val length: Int?,             // for arrays: the number of elements, for strings: number of characters *including* the terminating 0-byte
+               position: Position) :
    StNode(name, StNodeType.MEMVAR, position) {
    override fun printProperties() {
        print("$name  dt=$dt address=${address.toHex()}")
@@ -30,6 +30,10 @@ sealed class PtNode(val position: Position) {
        children.add(index, child)
        child.parent = this
    }
+
+    fun definingBlock() = findParentNode<PtBlock>(this)
+    fun definingSub() = findParentNode<PtSub>(this)
+    fun definingAsmSub() = findParentNode<PtAsmSub>(this)
 }


@@ -76,10 +80,18 @@ class PtProgram(
 class PtBlock(name: String,
              val address: UInt?,
              val library: Boolean,
+              val forceOutput: Boolean,
+              val alignment: BlockAlignment,
              position: Position
 ) : PtNamedNode(name, position) {
    override fun printProperties() {
-        print("$name  addr=$address  library=$library")
+        print("$name  addr=$address  library=$library  forceOutput=$forceOutput  alignment=$alignment")
+    }
+
+    enum class BlockAlignment {
+        NONE,
+        WORD,
+        PAGE
    }
 }

@@ -116,3 +128,17 @@ class PtNop(position: Position): PtNode(position) {
 class PtScopeVarsDecls(position: Position): PtNode(position) {
    override fun printProperties() {}
 }
+
+
+
+// find the parent node of a specific type or interface
+// (useful to figure out in what namespace/block something is defined, etc.)
+inline fun <reified T> findParentNode(node: PtNode): T? {
+    var candidate = node.parent
+    while(candidate !is T && candidate !is PtProgram)
+        candidate = candidate.parent
+    return if(candidate is PtProgram)
+        null
+    else
+        candidate as T
+}
@@ -3,14 +3,38 @@ package prog8.code.ast
 import prog8.code.core.DataType
 import prog8.code.core.Encoding
 import prog8.code.core.Position
+import java.util.*
+import kotlin.math.round


 sealed class PtExpression(val type: DataType, position: Position) : PtNode(position) {
+
+    init {
+        if(type==DataType.BOOL)
+            throw IllegalArgumentException("bool should have become ubyte @$position")
+    }
+
    override fun printProperties() {
        print(type)
    }
-}

+    infix fun isSameAs(other: PtExpression): Boolean {
+        return when(this) {
+            is PtAddressOf -> other is PtAddressOf && other.type==type && other.identifier isSameAs identifier
+            is PtArrayIndexer -> other is PtArrayIndexer && other.type==type && other.variable isSameAs variable && other.index isSameAs index
+            is PtBinaryExpression -> other is PtBinaryExpression && other.left isSameAs left && other.right isSameAs right
+            is PtContainmentCheck -> other is PtContainmentCheck && other.type==type && other.element isSameAs element && other.iterable isSameAs iterable
+            is PtIdentifier -> other is PtIdentifier && other.type==type && other.targetName==targetName
+            is PtMachineRegister -> other is PtMachineRegister && other.type==type && other.register==register
+            is PtMemoryByte -> other is PtMemoryByte && other.address isSameAs address
+            is PtNumber -> other is PtNumber && other.type==type && other.number==number
+            is PtPrefix -> other is PtPrefix && other.type==type && other.operator==operator && other.value isSameAs value
+            is PtRange -> other is PtRange && other.type==type && other.from==from && other.to==to && other.step==step
+            is PtTypeCast -> other is PtTypeCast && other.type==type && other.value isSameAs value
+            else -> false
+        }
+    }
+}

 class PtAddressOf(position: Position) : PtExpression(DataType.UWORD, position) {
    val identifier: PtIdentifier
@@ -26,10 +50,21 @@ class PtArrayIndexer(type: DataType, position: Position): PtExpression(type, pos
 }


-class PtArray(type: DataType, position: Position): PtExpression(type, position)
+class PtArray(type: DataType, position: Position): PtExpression(type, position) {
+    override fun hashCode(): Int = Objects.hash(children, type)
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is PtArray)
+            return false
+        return type==other.type && children == other.children
+    }
+}


-class PtBuiltinFunctionCall(val name: String, val void: Boolean, type: DataType, position: Position) : PtExpression(type, position) {
+class PtBuiltinFunctionCall(val name: String,
+                            val void: Boolean,
+                            val hasNoSideEffects: Boolean,
+                            type: DataType,
+                            position: Position) : PtExpression(type, position) {
    init {
        if(!void)
            require(type!=DataType.UNDEFINED)
@@ -38,12 +73,13 @@ class PtBuiltinFunctionCall(val name: String, val void: Boolean, type: DataType,
    val args: List<PtExpression>
        get() = children.map { it as PtExpression }
    override fun printProperties() {
-        print("$name void=$void")
+        print("$name void=$void noSideFx=$hasNoSideEffects")
    }
 }


 class PtBinaryExpression(val operator: String, type: DataType, position: Position): PtExpression(type, position) {
+    // note: "and", "or", "xor" do not occur anymore as operators. They've been replaced int the ast by their bitwise versions &, |, ^.
    val left: PtExpression
        get() = children[0] as PtExpression
    val right: PtExpression
@@ -95,19 +131,30 @@ class PtMemoryByte(position: Position) : PtExpression(DataType.UBYTE, position)


 class PtNumber(type: DataType, val number: Double, position: Position) : PtExpression(type, position) {
+
+    init {
+        if(type==DataType.BOOL)
+            throw IllegalArgumentException("bool should have become ubyte @$position")
+        if(type!=DataType.FLOAT) {
+            val rounded = round(number)
+            if (rounded != number)
+                throw IllegalArgumentException("refused rounding of float to avoid loss of precision @$position")
+        }
+    }
+
    override fun printProperties() {
        print("$number ($type)")
    }
-}

+    override fun hashCode(): Int = Objects.hash(type, number)

-class PtPipe(type: DataType, val void: Boolean, position: Position) : PtExpression(type, position) {
-    init {
-        if(!void)
-            require(type!=DataType.UNDEFINED)
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is PtNumber)
+            return false
+        return number==other.number
    }

-    override fun printProperties() {}
+    operator fun compareTo(other: PtNumber): Int = number.compareTo(other.number)
 }


@@ -115,6 +162,12 @@ class PtPrefix(val operator: String, type: DataType, position: Position): PtExpr
    val value: PtExpression
        get() = children.single() as PtExpression

+    init {
+        // note: the "not" operator may no longer occur in the ast; not x should have been replaced with x==0
+        if(operator !in setOf("+", "-", "~"))
+            throw IllegalArgumentException("invalid prefix operator: $operator")
+    }
+
    override fun printProperties() {
        print(operator)
    }
@@ -137,6 +190,13 @@ class PtString(val value: String, val encoding: Encoding, position: Position) :
    override fun printProperties() {
        print("$encoding:\"$value\"")
    }
+
+    override fun hashCode(): Int = Objects.hash(value, encoding)
+    override fun equals(other: Any?): Boolean {
+        if(other==null || other !is PtString)
+            return false
+        return value==other.value && encoding == other.encoding
+    }
 }


@@ -144,3 +204,15 @@ class PtTypeCast(type: DataType, position: Position) : PtExpression(type, positi
    val value: PtExpression
        get() = children.single() as PtExpression
 }
+
+
+// special node that isn't created from compiling user code, but used internally
+class PtMachineRegister(val register: Int, type: DataType, position: Position) : PtExpression(type, position) {
+    override fun printProperties() {
+        print("reg=$register  $type")
+    }
+}
+
+
+fun constValue(expr: PtExpression): Double? = if(expr is PtNumber) expr.number else null
+fun constIntValue(expr: PtExpression): Int? = if(expr is PtNumber) expr.number.toInt() else null
@@ -38,18 +38,43 @@ class PtSubroutineParameter(val name: String, val type: DataType, position: Posi
 }


-class PtAssignment(val augmentable: Boolean, position: Position) : PtNode(position) {
+class PtAssignment(position: Position) : PtNode(position) {
    val target: PtAssignTarget
        get() = children[0] as PtAssignTarget
    val value: PtExpression
        get() = children[1] as PtExpression

-    override fun printProperties() {
-        print("aug=$augmentable")
+    override fun printProperties() { }
+
+    val isInplaceAssign: Boolean by lazy {
+        val target = target.children.single() as PtExpression
+        when(val source = value) {
+            is PtArrayIndexer -> {
+                if(target is PtArrayIndexer && source.type==target.type) {
+                    if(target.variable isSameAs source.variable) {
+                        target.index isSameAs source.index
+                    }
+                }
+                false
+            }
+            is PtIdentifier -> target is PtIdentifier && target.type==source.type && target.targetName==source.targetName
+            is PtMachineRegister -> target is PtMachineRegister && target.register==source.register
+            is PtMemoryByte -> target is PtMemoryByte && target.address isSameAs source.address
+            is PtNumber -> target is PtNumber && target.type == source.type && target.number==source.number
+            is PtAddressOf -> target is PtAddressOf && target.identifier isSameAs source.identifier
+            is PtPrefix -> {
+                (target is PtPrefix && target.operator==source.operator && target.value isSameAs source.value)
+                        ||
+                (target is PtIdentifier && (source.value as? PtIdentifier)?.targetName==target.targetName)
+            }
+            is PtTypeCast -> target is PtTypeCast && target.type==source.type && target.value isSameAs source.value
+            is PtBinaryExpression ->
+                target isSameAs source.left
+            else -> false
+        }
    }
 }

-
 class PtAssignTarget(position: Position) : PtNode(position) {
    val identifier: PtIdentifier?
        get() = children.single() as? PtIdentifier
@@ -62,9 +87,9 @@ class PtAssignTarget(position: Position) : PtNode(position) {
        get() {
            return when(val tgt = children.single()) {
                is PtIdentifier -> tgt.type
-                is PtArrayIndexer -> tgt.type       // TODO array to elt type?
+                is PtArrayIndexer -> tgt.type
                is PtMemoryByte -> tgt.type
-                else -> throw AssemblyError("weird dt")
+                else -> throw AssemblyError("weird target $tgt")
            }
        }

@@ -97,8 +122,8 @@ class PtForLoop(position: Position) : PtNode(position) {


 class PtIfElse(position: Position) : PtNode(position) {
-    val condition: PtExpression
-        get() = children[0] as PtExpression
+    val condition: PtBinaryExpression
+        get() = children[0] as PtBinaryExpression
    val ifScope: PtNodeGroup
        get() = children[1] as PtNodeGroup
    val elseScope: PtNodeGroup
@@ -24,9 +24,9 @@ compileTestKotlin {
 }

 dependencies {
-    implementation project(':virtualmachine')
+    // should have no dependencies to other modules
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"
 }

 sourceSets {
@@ -10,6 +10,5 @@
    <orderEntry type="sourceFolder" forTests="false" />
    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
-    <orderEntry type="module" module-name="virtualmachine" />
  </component>
 </module>
@@ -20,5 +20,7 @@ class CompilationOptions(val output: OutputType,
                         var asmQuiet: Boolean = false,
                         var asmListfile: Boolean = false,
                         var experimentalCodegen: Boolean = false,
-                         var outputDir: Path = Path("")
+                         var evalStackBaseAddress: UInt? = null,
+                         var outputDir: Path = Path(""),
+                         var symbolDefs: Map<String, String> = emptyMap()
 )
@@ -0,0 +1,89 @@
+package prog8.code.core
+
+import kotlin.math.abs
+
+fun Number.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    // negative values are prefixed with '-'.
+    val integer = this.toInt()
+    if(integer<0)
+        return '-' + abs(integer).toHex()
+    return when (integer) {
+        in 0 until 16 -> integer.toString()
+        in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
+        in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0')
+        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+    }
+}
+
+fun UInt.toHex(): String {
+    //  0..15 -> "0".."15"
+    //  16..255 -> "$10".."$ff"
+    //  256..65536 -> "$0100".."$ffff"
+    return when (this) {
+        in 0u until 16u -> this.toString()
+        in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0')
+        in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0')
+        else -> throw IllegalArgumentException("number too large for 16 bits $this")
+    }
+}
+
+fun Char.escape(): Char = this.toString().escape()[0]
+
+fun String.escape(): String {
+    val es = this.map {
+        when(it) {
+            '\t' -> "\\t"
+            '\n' -> "\\n"
+            '\r' -> "\\r"
+            '"' -> "\\\""
+            in '\u8000'..'\u80ff' -> "\\x" + (it.code - 0x8000).toString(16).padStart(2, '0')       // 'ugly' passthrough hack
+            in '\u0000'..'\u00ff' -> it.toString()
+            else -> "\\u" + it.code.toString(16).padStart(4, '0')
+        }
+    }
+    return es.joinToString("")
+}
+
+fun String.unescape(): String {
+    val result = mutableListOf<Char>()
+    val iter = this.iterator()
+    while(iter.hasNext()) {
+        val c = iter.nextChar()
+        if(c=='\\') {
+            val ec = iter.nextChar()
+            result.add(when(ec) {
+                '\\' -> '\\'
+                'n' -> '\n'
+                'r' -> '\r'
+                '"' -> '"'
+                '\'' -> '\''
+                'u' -> {
+                    try {
+                        "${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}${iter.nextChar()}".toInt(16).toChar()
+                    } catch (sb: StringIndexOutOfBoundsException) {
+                        throw IllegalArgumentException("invalid \\u escape sequence")
+                    } catch (nf: NumberFormatException) {
+                        throw IllegalArgumentException("invalid \\u escape sequence")
+                    }
+                }
+                'x' -> {
+                    try {
+                        val hex = ("" + iter.nextChar() + iter.nextChar()).toInt(16)
+                        (0x8000 + hex).toChar()         // 'ugly' pass-through hack
+                    } catch (sb: StringIndexOutOfBoundsException) {
+                        throw IllegalArgumentException("invalid \\x escape sequence")
+                    } catch (nf: NumberFormatException) {
+                        throw IllegalArgumentException("invalid \\x escape sequence")
+                    }
+                }
+                else -> throw IllegalArgumentException("invalid escape char in string: \\$ec")
+            })
+        } else {
+            result.add(c)
+        }
+    }
+    return result.joinToString("")
+}
@@ -6,12 +6,14 @@ enum class DataType {
    UWORD,              // pass by value
    WORD,               // pass by value
    FLOAT,              // pass by value
+    BOOL,               // pass by value
    STR,                // pass by reference
    ARRAY_UB,           // pass by reference
    ARRAY_B,            // pass by reference
    ARRAY_UW,           // pass by reference
    ARRAY_W,            // pass by reference
    ARRAY_F,            // pass by reference
+    ARRAY_BOOL,         // pass by reference
    UNDEFINED;

    /**
@@ -19,11 +21,12 @@ enum class DataType {
     */
    infix fun isAssignableTo(targetType: DataType) =
        when(this) {
-            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT)
+            BOOL -> targetType.oneOf(BOOL, BYTE, UBYTE, WORD, UWORD, FLOAT)
+            UBYTE -> targetType.oneOf(UBYTE, WORD, UWORD, FLOAT, BOOL)
            BYTE -> targetType.oneOf(BYTE, WORD, FLOAT)
            UWORD -> targetType.oneOf(UWORD, FLOAT)
            WORD -> targetType.oneOf(WORD, FLOAT)
-            FLOAT -> targetType == FLOAT
+            FLOAT -> targetType.oneOf(FLOAT)
            STR -> targetType.oneOf(STR, UWORD)
            in ArrayDatatypes -> targetType == this
            else -> false
@@ -53,13 +56,7 @@ enum class DataType {
 enum class CpuRegister {
    A,
    X,
-    Y;
-
-    fun asRegisterOrPair(): RegisterOrPair = when(this) {
-        A -> RegisterOrPair.A
-        X -> RegisterOrPair.X
-        Y -> RegisterOrPair.Y
-    }
+    Y
 }

 enum class RegisterOrPair {
@@ -102,31 +99,33 @@ enum class Statusflag {
 enum class BranchCondition {
    CS,
    CC,
-    EQ,
+    EQ,     // EQ == Z
    Z,
-    NE,
+    NE,     // NE == NZ
    NZ,
+    MI,     // MI == NEG
+    NEG,
+    PL,     // PL == POS
+    POS,
    VS,
    VC,
-    MI,
-    NEG,
-    PL,
-    POS
 }


-val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE)
+val ByteDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.BOOL)
 val WordDatatypes = arrayOf(DataType.UWORD, DataType.WORD)
-val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
-val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
+val IntegerDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.BOOL)
+val IntegerDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
+val NumericDatatypes = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT, DataType.BOOL)
+val NumericDatatypesNoBool = arrayOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
 val SignedDatatypes =  arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
-val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
+val ArrayDatatypes = arrayOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F, DataType.ARRAY_BOOL)
 val StringlyDatatypes = arrayOf(DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B, DataType.UWORD)
 val IterableDatatypes = arrayOf(
    DataType.STR,
    DataType.ARRAY_UB, DataType.ARRAY_B,
    DataType.ARRAY_UW, DataType.ARRAY_W,
-    DataType.ARRAY_F
+    DataType.ARRAY_F, DataType.ARRAY_BOOL
 )
 val PassByValueDatatypes = NumericDatatypes
 val PassByReferenceDatatypes = IterableDatatypes
@@ -136,14 +135,16 @@ val ArrayToElementTypes = mapOf(
    DataType.ARRAY_UB to DataType.UBYTE,
    DataType.ARRAY_W to DataType.WORD,
    DataType.ARRAY_UW to DataType.UWORD,
-    DataType.ARRAY_F to DataType.FLOAT
+    DataType.ARRAY_F to DataType.FLOAT,
+    DataType.ARRAY_BOOL to DataType.BOOL
 )
 val ElementToArrayTypes = mapOf(
    DataType.BYTE to DataType.ARRAY_B,
    DataType.UBYTE to DataType.ARRAY_UB,
    DataType.WORD to DataType.ARRAY_W,
    DataType.UWORD to DataType.ARRAY_UW,
-    DataType.FLOAT to DataType.ARRAY_F
+    DataType.FLOAT to DataType.ARRAY_F,
+    DataType.BOOL to DataType.ARRAY_BOOL
 )
 val Cx16VirtualRegisters = arrayOf(
    RegisterOrPair.R0, RegisterOrPair.R1, RegisterOrPair.R2, RegisterOrPair.R3,
@@ -18,8 +18,8 @@ interface IMachineDefinition {
    val FLOAT_MAX_NEGATIVE: Double
    val FLOAT_MAX_POSITIVE: Double
    val FLOAT_MEM_SIZE: Int
-    val ESTACK_LO: UInt
-    val ESTACK_HI: UInt
+    var ESTACK_LO: UInt
+    var ESTACK_HI: UInt
    val PROGRAM_LOAD_ADDRESS : UInt

    val opcodeNames: Set<String>
@@ -32,4 +32,9 @@ interface IMachineDefinition {
    fun importLibs(compilerOptions: CompilationOptions, compilationTargetName: String): List<String>
    fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path)
    fun isIOAddress(address: UInt): Boolean
+    fun overrideEvalStack(evalStackBaseAddress: UInt) {
+        require(evalStackBaseAddress and 255u == 0u)
+        ESTACK_LO = evalStackBaseAddress
+        ESTACK_HI = evalStackBaseAddress + 256u
+    }
 }
@@ -0,0 +1,19 @@
+package prog8.code.core
+
+val AssociativeOperators = setOf("+", "*", "&", "|", "^", "==", "!=")
+val ComparisonOperators = setOf("==", "!=", "<", ">", "<=", ">=")
+val LogicalOperators = setOf("and", "or", "xor", "not")
+val AugmentAssignmentOperators = setOf("+", "-", "/", "*", "&", "|", "^", "<<", ">>", "%")
+val BitwiseOperators = setOf("&", "|", "^", "~")
+// val InvalidOperatorsForBoolean = setOf("+", "-", "*", "/", "%", "<<", ">>") + BitwiseOperators
+
+fun invertedComparisonOperator(operator: String) =
+    when (operator) {
+        "==" -> "!="
+        "!=" -> "=="
+        "<" -> ">="
+        ">" -> "<="
+        "<=" -> ">"
+        ">=" -> "<"
+        else -> null
+    }
@@ -1,16 +1,22 @@
 package prog8.code.core

+import java.nio.file.InvalidPathException
 import kotlin.io.path.Path
 import kotlin.io.path.absolute

 data class Position(val file: String, val line: Int, val startCol: Int, val endCol: Int) {
    override fun toString(): String = "[$file: line $line col ${startCol+1}-${endCol+1}]"
    fun toClickableStr(): String {
-        val path = Path(file).absolute().normalize()
-        return "file://$path:$line:$startCol:"
+        return try {
+            val path = Path(file).absolute().normalize().toString()
+            "file://$path:$line:$startCol:"
+        } catch(x: InvalidPathException) {
+            // this can occur on Windows when the source origin contains "invalid" characters such as ':'
+            "file://$file:$line:$startCol:"
+        }
    }

    companion object {
-        val DUMMY = Position("<dummy>", 0, 0, 0)
+        val DUMMY = Position("~dummy~", 0, 0, 0)
    }
 }
@@ -34,7 +34,7 @@ sealed class SourceCode {
     * Where this [SourceCode] instance came from.
     * This can be one of the following:
     * * a normal string representation of a [java.nio.file.Path], if it originates from a file (see [File])
-     * * `$stringSourcePrefix44c56085>` if was created via [String]
+     * * `string:44c56085` if was created via [String]
     * * `library:/x/y/z.ext` if it is a library file that was loaded from resources (see [Resource])
     */
    abstract val origin: String
@@ -55,7 +55,7 @@ sealed class SourceCode {
         * filename prefix to designate library files that will be retreived from internal resources rather than disk
         */
        const val libraryFilePrefix = "library:"
-        const val stringSourcePrefix = "<String@"
+        const val stringSourcePrefix = "string:"
        val curdir: Path = Path(".").toAbsolutePath()
        fun relative(path: Path): Path = curdir.relativize(path.toAbsolutePath())
        fun isRegularFilesystemPath(pathString: String) =
@@ -64,12 +64,12 @@ sealed class SourceCode {

    /**
     * Turn a plain String into a [SourceCode] object.
-     * [origin] will be something like `$stringSourcePrefix44c56085>`.
+     * [origin] will be something like `string:44c56085`.
     */
    class Text(override val text: String): SourceCode() {
        override val isFromResources = false
        override val isFromFilesystem = false
-        override val origin = "$stringSourcePrefix${System.identityHashCode(text).toString(16)}>"
+        override val origin = "$stringSourcePrefix${System.identityHashCode(text).toString(16)}"
        override val name = "<unnamed-text>"
    }

@@ -1,31 +0,0 @@
-package prog8.code.core
-
-import kotlin.math.abs
-
-fun Number.toHex(): String {
-    //  0..15 -> "0".."15"
-    //  16..255 -> "$10".."$ff"
-    //  256..65536 -> "$0100".."$ffff"
-    // negative values are prefixed with '-'.
-    val integer = this.toInt()
-    if(integer<0)
-        return '-' + abs(integer).toHex()
-    return when (integer) {
-        in 0 until 16 -> integer.toString()
-        in 0 until 0x100 -> "$"+integer.toString(16).padStart(2,'0')
-        in 0 until 0x10000 -> "$"+integer.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
-    }
-}
-
-fun UInt.toHex(): String {
-    //  0..15 -> "0".."15"
-    //  16..255 -> "$10".."$ff"
-    //  256..65536 -> "$0100".."$ffff"
-    return when (this) {
-        in 0u until 16u -> this.toString()
-        in 0u until 0x100u -> "$"+this.toString(16).padStart(2,'0')
-        in 0u until 0x10000u -> "$"+this.toString(16).padStart(4,'0')
-        else -> throw IllegalArgumentException("number too large for 16 bits $this")
-    }
-}
@@ -15,8 +15,8 @@ class AtariMachineDefinition: IMachineDefinition {
    override val PROGRAM_LOAD_ADDRESS = 0x2000u

    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive      // TODO
-    override val ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive      // TODO
+    override var ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive      // TODO
+    override var ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive      // TODO

    override lateinit var zeropage: Zeropage

@@ -16,8 +16,8 @@ class C128MachineDefinition: IMachineDefinition {
    override val PROGRAM_LOAD_ADDRESS = 0x1c01u

    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive
-    override val ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive
+    override var ESTACK_LO = 0x1a00u     //  $1a00-$1aff inclusive
+    override var ESTACK_HI = 0x1b00u     //  $1b00-$1bff inclusive

    override lateinit var zeropage: Zeropage

@@ -16,8 +16,8 @@ class C64MachineDefinition: IMachineDefinition {
    override val PROGRAM_LOAD_ADDRESS = 0x0801u

    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0xce00u     //  $ce00-$ceff inclusive
-    override val ESTACK_HI = 0xcf00u     //  $ce00-$ceff inclusive
+    override var ESTACK_LO = 0xce00u     //  $ce00-$ceff inclusive
+    override var ESTACK_HI = 0xcf00u     //  $ce00-$ceff inclusive

    override lateinit var zeropage: Zeropage

@@ -29,10 +29,9 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
        } else {
            if (options.zeropage == ZeropageType.KERNALSAFE || options.zeropage == ZeropageType.FLOATSAFE) {
                free.addAll(listOf(
-                        0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11,
-                        0x16, 0x17, 0x18, 0x19, 0x1a,
-                        0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21,
-                        0x22, 0x23, 0x24, 0x25,
+                        0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f,
+                        0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f,
+                        0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
                        0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46,
                        0x47, 0x48, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x51, 0x52, 0x53,
                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
@@ -48,8 +47,8 @@ class C64Zeropage(options: CompilationOptions) : Zeropage(options) {
            if (options.zeropage == ZeropageType.FLOATSAFE) {
                // remove the zeropage locations used for floating point operations from the free list
                free.removeAll(listOf(
-                        0x22, 0x23, 0x24, 0x25,
-                        0x10, 0x11, 0x12, 0x26, 0x27, 0x28, 0x29, 0x2a,
+                        0x03, 0x04, 0x10, 0x11, 0x12,
+                        0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a,
                        0x57, 0x58, 0x59, 0x5a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f, 0x60,
                        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
                        0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
@@ -15,8 +15,8 @@ class CX16MachineDefinition: IMachineDefinition {
    override val PROGRAM_LOAD_ADDRESS = 0x0801u

    // the 2*256 byte evaluation stack (on which bytes, words, and even floats are stored during calculations)
-    override val ESTACK_LO = 0x0400u        //  $0400-$04ff inclusive
-    override val ESTACK_HI = 0x0500u        //  $0500-$05ff inclusive
+    override var ESTACK_LO = 0x0400u        //  $0400-$04ff inclusive
+    override var ESTACK_HI = 0x0500u        //  $0500-$05ff inclusive

    override lateinit var zeropage: Zeropage

@@ -45,8 +45,9 @@ class CX16Zeropage(options: CompilationOptions) : Zeropage(options) {

            removeReservedFromFreePool()

-            // note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
-            // however, to be able for the compiler to "see" them as zero page variables, we have to register them here as well.
+            // Note: the 16 virtual registers R0-R15 are not regular allocated variables, they're *memory mapped* elsewhere to fixed addresses.
+            // However, to be able for the compiler to "see" them as zero page variables, we have to register them here as well.
+            // This is important because the compiler sometimes treats ZP variables more efficiently (for example if it's a pointer)
            for(reg in 0..15) {
                allocatedVariables[listOf("cx16", "r${reg}")]   = ZpAllocation((2+reg*2).toUInt(), DataType.UWORD, 2)        // cx16.r0 .. cx16.r15
                allocatedVariables[listOf("cx16", "r${reg}s")]  = ZpAllocation((2+reg*2).toUInt(), DataType.WORD, 2)        // cx16.r0s .. cx16.r15s
@@ -4,9 +4,6 @@ import prog8.code.core.CompilationOptions
 import prog8.code.core.CpuType
 import prog8.code.core.IMachineDefinition
 import prog8.code.core.Zeropage
-import prog8.vm.Assembler
-import prog8.vm.Memory
-import prog8.vm.VirtualMachine
 import java.io.File
 import java.nio.file.Path

@@ -17,11 +14,11 @@ class VirtualMachineDefinition: IMachineDefinition {

    override val FLOAT_MAX_POSITIVE = Float.MAX_VALUE.toDouble()
    override val FLOAT_MAX_NEGATIVE = -Float.MAX_VALUE.toDouble()
-    override val FLOAT_MEM_SIZE = 4
+    override val FLOAT_MEM_SIZE = 4             // 32-bits floating point
    override val PROGRAM_LOAD_ADDRESS = 0u      // not actually used

-    override val ESTACK_LO = 0u                 // not actually used
-    override val ESTACK_HI = 0u                 // not actually used
+    override var ESTACK_LO = 0u                 // not actually used
+    override var ESTACK_HI = 0u                 // not actually used

    override lateinit var zeropage: Zeropage     // not actually used

@@ -33,14 +30,10 @@ class VirtualMachineDefinition: IMachineDefinition {

    override fun launchEmulator(selectedEmulator: Int, programNameWithPath: Path) {
        println("\nStarting Virtual Machine...")
+        // to not have external module dependencies we launch the virtual machine via reflection
+        val vm = Class.forName("prog8.vm.VmRunner").getDeclaredConstructor().newInstance() as IVirtualMachineRunner
        val source = File("$programNameWithPath.p8virt").readText()
-        val (memsrc, programsrc) = source.split("------PROGRAM------".toRegex(), 2)
-        val memory = Memory()
-        val assembler = Assembler()
-        assembler.initializeMemory(memsrc, memory)
-        val program = assembler.assembleProgram(programsrc)
-        val vm = VirtualMachine(memory, program)
-        vm.run(throttle = true)
+        vm.runProgram(source, true)
    }

    override fun isIOAddress(address: UInt): Boolean = false
@@ -49,3 +42,7 @@ class VirtualMachineDefinition: IMachineDefinition {

    override val opcodeNames = emptySet<String>()
 }
+
+interface IVirtualMachineRunner {
+    fun runProgram(source: String, throttle: Boolean)
+}
@@ -29,7 +29,7 @@ dependencies {
    implementation project(':compilerAst')
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"

 }

@@ -1,7 +1,10 @@
 package prog8.codegen.cpu6502

 import com.github.michaelbull.result.fold
-import prog8.ast.*
+import prog8.ast.IFunctionCall
+import prog8.ast.Node
+import prog8.ast.ParentSentinel
+import prog8.ast.Program
 import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
 import prog8.ast.statements.*
@@ -10,13 +13,11 @@ import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
 import prog8.compiler.BuiltinFunctions
 import prog8.compiler.builtinFunctionReturnType
-import prog8.code.core.SourceCode
 import java.util.*
 import kotlin.io.path.Path
 import kotlin.io.path.writeLines


-internal const val generatedLabelPrefix = "prog8_label_"
 internal const val subroutineFloatEvalResultVar1 = "prog8_float_eval_result1"
 internal const val subroutineFloatEvalResultVar2 = "prog8_float_eval_result2"

@@ -71,19 +72,12 @@ class AsmGen(internal val program: Program,

    internal fun isTargetCpu(cpu: CpuType) = options.compTarget.machine.cpu == cpu

-    private var generatedLabelSequenceNumber: Int = 0
-
-    internal fun makeLabel(postfix: String): String {
-        generatedLabelSequenceNumber++
-        return "${generatedLabelPrefix}${generatedLabelSequenceNumber}_$postfix"
-    }
-
    internal fun outputSourceLine(node: Node) {
        out(" ;\tsrc line: ${node.position.file}:${node.position.line}")
    }

    internal fun out(str: String, splitlines: Boolean = true) {
-        val fragment = (if(" | " in str) str.replace("|", "\n") else str).trim('\n')
+        val fragment = (if(splitlines && " | " in str) str.replace("|", "\n") else str).trim('\n')
        if (splitlines) {
            for (line in fragment.splitToSequence('\n')) {
                val trimmed = if (line.startsWith(' ')) "\t" + line.trim() else line
@@ -332,7 +326,6 @@ class AsmGen(internal val program: Program,
            is RepeatLoop -> translate(stmt)
            is When -> translate(stmt)
            is AnonymousScope -> translate(stmt)
-            is Pipe -> translatePipeExpression(stmt.source, stmt.segments, stmt, isStatement = true, pushResultOnEstack = false)
            is VarDecl -> { /* do nothing; variables are handled elsewhere */ }
            is BuiltinFunctionPlaceholder -> throw AssemblyError("builtin function should not have placeholder anymore")
            is UntilLoop -> throw AssemblyError("do..until should have been converted to jumps")
@@ -442,12 +435,6 @@ class AsmGen(internal val program: Program,
    internal fun translateBuiltinFunctionCallExpression(bfc: BuiltinFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?) =
            builtinFunctionsAsmGen.translateFunctioncallExpression(bfc, resultToStack, resultRegister)

-    private fun translateBuiltinFunctionCallExpression(name: String, singleArg:AsmAssignSource, scope: Subroutine): DataType =
-            builtinFunctionsAsmGen.translateUnaryFunctioncall(name, singleArg, false, scope)
-
-    private fun translateBuiltinFunctionCallStatement(name: String, singleArg: AsmAssignSource, scope: Subroutine) =
-            builtinFunctionsAsmGen.translateUnaryFunctioncall(name, singleArg, true, scope)
-
    internal fun translateFunctionCall(functionCallExpr: FunctionCallExpression, isExpression: Boolean) =
            functioncallAsmGen.translateFunctionCall(functionCallExpr, isExpression)

@@ -548,7 +535,7 @@ class AsmGen(internal val program: Program,
            if(jump is Jump) {
                translateCompareAndJumpIfTrue(booleanCondition, jump)
            } else {
-                val endLabel = makeLabel("if_end")
+                val endLabel = program.makeLabel("if_end")
                translateCompareAndJumpIfFalse(booleanCondition, endLabel)
                translate(stmt.truepart)
                out(endLabel)
@@ -556,8 +543,8 @@ class AsmGen(internal val program: Program,
        }
        else {
            // both true and else parts
-            val elseLabel = makeLabel("if_else")
-            val endLabel = makeLabel("if_end")
+            val elseLabel = program.makeLabel("if_else")
+            val endLabel = program.makeLabel("if_end")
            translateCompareAndJumpIfFalse(booleanCondition, elseLabel)
            translate(stmt.truepart)
            jmp(endLabel)
@@ -573,7 +560,7 @@ class AsmGen(internal val program: Program,
    }

    private fun translate(stmt: RepeatLoop) {
-        val endLabel = makeLabel("repeatend")
+        val endLabel = program.makeLabel("repeatend")
        loopEndLabels.push(endLabel)

        when (stmt.iterations) {
@@ -626,7 +613,7 @@ class AsmGen(internal val program: Program,

    private fun repeatWordCount(count: Int, stmt: RepeatLoop) {
        require(count in 257..65535)
-        val repeatLabel = makeLabel("repeat")
+        val repeatLabel = program.makeLabel("repeat")
        if(isTargetCpu(CpuType.CPU65c02)) {
            val counterVar = createRepeatCounterVar(DataType.UWORD, true, stmt)
            out("""
@@ -667,7 +654,7 @@ $repeatLabel""")
    private fun repeatWordCountInAY(endLabel: String, stmt: RepeatLoop) {
        // note: A/Y must have been loaded with the number of iterations!
        // no need to explicitly test for 0 iterations as this is done in the countdown logic below
-        val repeatLabel = makeLabel("repeat")
+        val repeatLabel = program.makeLabel("repeat")
        val counterVar = createRepeatCounterVar(DataType.UWORD, false, stmt)
        out("""
                sta  $counterVar
@@ -688,7 +675,7 @@ $repeatLabel    lda  $counterVar

    private fun repeatByteCount(count: Int, stmt: RepeatLoop) {
        require(count in 2..256)
-        val repeatLabel = makeLabel("repeat")
+        val repeatLabel = program.makeLabel("repeat")
        if(isTargetCpu(CpuType.CPU65c02)) {
            val counterVar = createRepeatCounterVar(DataType.UBYTE, true, stmt)
            out("  lda  #${count and 255} |  sta  $counterVar")
@@ -706,7 +693,7 @@ $repeatLabel    lda  $counterVar

    private fun repeatCountInY(stmt: RepeatLoop, endLabel: String) {
        // note: Y must just have been loaded with the (variable) number of loops to be performed!
-        val repeatLabel = makeLabel("repeat")
+        val repeatLabel = program.makeLabel("repeat")
        if(isTargetCpu(CpuType.CPU65c02)) {
            val counterVar = createRepeatCounterVar(DataType.UBYTE, true, stmt)
            out("  beq  $endLabel |  sty  $counterVar")
@@ -743,7 +730,7 @@ $repeatLabel    lda  $counterVar
            }
        }

-        val counterVar = makeLabel("counter")
+        val counterVar = program.makeLabel("counter")
        when(dt) {
            DataType.UBYTE, DataType.UWORD -> {
                val result = zeropage.allocate(listOf(counterVar), dt, null, stmt.position, errors)
@@ -758,7 +745,7 @@ $repeatLabel    lda  $counterVar
    }

    private fun translate(stmt: When) {
-        val endLabel = makeLabel("choice_end")
+        val endLabel = program.makeLabel("choice_end")
        val choiceBlocks = mutableListOf<Pair<String, AnonymousScope>>()
        val conditionDt = stmt.condition.inferType(program)
        if(!conditionDt.isKnown)
@@ -769,7 +756,7 @@ $repeatLabel    lda  $counterVar
            assignExpressionToRegister(stmt.condition, RegisterOrPair.AY)

        for(choice in stmt.choices) {
-            val choiceLabel = makeLabel("choice")
+            val choiceLabel = program.makeLabel("choice")
            if(choice.values==null) {
                // the else choice
                translate(choice.statements)
@@ -833,14 +820,14 @@ $repeatLabel    lda  $counterVar
        } else {
            if(stmt.elsepart.isEmpty()) {
                val instruction = branchInstruction(stmt.condition, true)
-                val elseLabel = makeLabel("branch_else")
+                val elseLabel = program.makeLabel("branch_else")
                out("  $instruction  $elseLabel")
                translate(stmt.truepart)
                out(elseLabel)
            } else {
                val instruction = branchInstruction(stmt.condition, true)
-                val elseLabel = makeLabel("branch_else")
-                val endLabel = makeLabel("branch_end")
+                val elseLabel = program.makeLabel("branch_else")
+                val endLabel = program.makeLabel("branch_end")
                out("  $instruction  $elseLabel")
                translate(stmt.truepart)
                jmp(endLabel)
@@ -947,7 +934,7 @@ $repeatLabel    lda  $counterVar
        assemblyLines.add(assembly)
    }

-    internal fun returnRegisterOfFunction(it: IdentifierReference, argumentTypesForBuiltinFunc: List<DataType>?): RegisterOrPair {
+    internal fun returnRegisterOfFunction(it: IdentifierReference): RegisterOrPair {
        return when (val targetRoutine = it.targetStatement(program)!!) {
            is BuiltinFunctionPlaceholder -> {
                val func = BuiltinFunctions.getValue(targetRoutine.name)
@@ -956,16 +943,11 @@ $repeatLabel    lda  $counterVar
                    in WordDatatypes -> RegisterOrPair.AY
                    DataType.FLOAT -> RegisterOrPair.FAC1
                    else -> {
-                        if(!func.hasReturn)
-                            throw AssemblyError("func has no returntype")
-                        else {
-                            val args = argumentTypesForBuiltinFunc!!.map { defaultZero(it, Position.DUMMY) }
-                            when(builtinFunctionReturnType(func.name, args, program).getOrElse { DataType.UNDEFINED }) {
-                                in ByteDatatypes -> RegisterOrPair.A
-                                in WordDatatypes -> RegisterOrPair.AY
-                                DataType.FLOAT -> RegisterOrPair.FAC1
-                                else -> throw AssemblyError("weird returntype")
-                            }
+                        when(builtinFunctionReturnType(func.name).getOrElse { DataType.UNDEFINED }) {
+                            in ByteDatatypes -> RegisterOrPair.A
+                            in WordDatatypes -> RegisterOrPair.AY
+                            DataType.FLOAT -> RegisterOrPair.FAC1
+                            else -> throw AssemblyError("weird returntype")
                        }
                    }
                }
@@ -1183,14 +1165,14 @@ $repeatLabel    lda  $counterVar
            return testVariableZeroAndJump(left, dt, operator, jumpIfFalseLabel)

        when(dt) {
-            DataType.UBYTE, DataType.UWORD -> {
+            DataType.BOOL, DataType.UBYTE, DataType.UWORD -> {
                if(operator=="<") {
                    out("  jmp  $jumpIfFalseLabel")
                    return
                } else if(operator==">=") {
                    return
                }
-                if(dt==DataType.UBYTE) {
+                if(dt==DataType.UBYTE || dt==DataType.BOOL) {
                    assignExpressionToRegister(left, RegisterOrPair.A, false)
                    if (left is IFunctionCall && !left.isSimple)
                        out("  cmp  #0")
@@ -1270,7 +1252,7 @@ $repeatLabel    lda  $counterVar
        // optimized code if the expression is just an identifier (variable)
        val varname = asmVariableName(variable)
        when(dt) {
-            DataType.UBYTE -> when(operator) {
+            DataType.UBYTE, DataType.BOOL -> when(operator) {
                "==" -> out("  lda  $varname |  bne  $jumpIfFalseLabel")
                "!=" -> out("  lda  $varname |  beq  $jumpIfFalseLabel")
                ">"  -> out("  lda  $varname |  beq  $jumpIfFalseLabel")
@@ -2815,114 +2797,6 @@ $repeatLabel    lda  $counterVar
        }
    }

-    internal fun translatePipeExpression(source: Expression, segments: List<Expression>, scope: Node, isStatement: Boolean, pushResultOnEstack: Boolean) {
-
-        // TODO more efficient code generation to avoid needless assignments to the temp var
-
-        // the source: an expression (could be anything) producing a value.
-        // one or more segment expressions, all are a IFunctionCall node, and LACKING the implicit first argument.
-        // when 'isStatement'=true, the last segment expression should be treated as a funcion call statement (discarding any result value if there is one)
-
-        val subroutine = scope.definingSubroutine!!
-        var valueDt = source.inferType(program).getOrElse { throw FatalAstException("invalid dt") }
-        var valueSource: AsmAssignSource =
-            if(source is IFunctionCall) {
-                val resultReg = returnRegisterOfFunction(source.target, listOf(valueDt))
-                assignExpressionToRegister(source, resultReg, valueDt in listOf(DataType.BYTE, DataType.WORD, DataType.FLOAT))
-                AsmAssignSource(SourceStorageKind.REGISTER, program, this, valueDt, register = resultReg)
-            } else {
-                AsmAssignSource.fromAstSource(source, program, this)
-            }
-
-        // the segments (except the last one): unary function calls taking a single param and producing a value.
-        //   directly assign their argument from the previous call's returnvalue.
-        segments.dropLast(1).forEach {
-            it as IFunctionCall
-            valueDt = translateUnaryFunctionCallWithArgSource(it.target, valueSource, false, subroutine)
-            val resultReg = returnRegisterOfFunction(it.target, listOf(valueDt))
-            valueSource = AsmAssignSource(SourceStorageKind.REGISTER, program, this, valueDt, register = resultReg)
-        }
-        // the last segment: unary function call taking a single param and optionally producing a result value.
-        val lastCall = segments.last() as IFunctionCall
-        if(isStatement) {
-            translateUnaryFunctionCallWithArgSource(lastCall.target, valueSource, true, subroutine)
-        } else {
-            valueDt = translateUnaryFunctionCallWithArgSource(lastCall.target, valueSource, false, subroutine)
-            if(pushResultOnEstack) {
-                when (valueDt) {
-                    in ByteDatatypes -> {
-                        out("  sta  P8ESTACK_LO,x |  dex")
-                    }
-                    in WordDatatypes -> {
-                        out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
-                    }
-                    DataType.FLOAT -> {
-                        out("  jsr  floats.push_fac1")
-                    }
-                    else -> throw AssemblyError("invalid dt")
-                }
-            }
-        }
-    }
-
-    private fun translateUnaryFunctionCallWithArgSource(target: IdentifierReference, singleArg: AsmAssignSource, isStatement: Boolean, scope: Subroutine): DataType {
-        when(val targetStmt = target.targetStatement(program)!!) {
-            is BuiltinFunctionPlaceholder -> {
-                return if(isStatement) {
-                    translateBuiltinFunctionCallStatement(targetStmt.name, singleArg, scope)
-                    DataType.UNDEFINED
-                } else {
-                    translateBuiltinFunctionCallExpression(targetStmt.name, singleArg, scope)
-                }
-            }
-            is Subroutine -> {
-                val argDt = targetStmt.parameters.single().type
-                if(targetStmt.isAsmSubroutine) {
-                    // argument via registers
-                    val argRegister = targetStmt.asmParameterRegisters.single().registerOrPair!!
-                    val assignArgument = AsmAssignment(
-                        singleArg,
-                        AsmAssignTarget.fromRegisters(argRegister, argDt in SignedDatatypes, scope, program, this),
-                        false, program.memsizer, target.position
-                    )
-                    translateNormalAssignment(assignArgument)
-                } else {
-                    val assignArgument: AsmAssignment =
-                        if(functioncallAsmGen.optimizeIntArgsViaRegisters(targetStmt)) {
-                            // argument goes via registers as optimization
-                            val paramReg: RegisterOrPair = when(argDt) {
-                                in ByteDatatypes -> RegisterOrPair.A
-                                in WordDatatypes -> RegisterOrPair.AY
-                                DataType.FLOAT -> RegisterOrPair.FAC1
-                                else -> throw AssemblyError("invalid dt")
-                            }
-                            AsmAssignment(
-                                singleArg,
-                                AsmAssignTarget(TargetStorageKind.REGISTER, program, this, argDt, scope, register = paramReg),
-                                false, program.memsizer, target.position
-                            )
-                        } else {
-                            // arg goes via parameter variable
-                            val argVarName = asmVariableName(targetStmt.scopedName + targetStmt.parameters.single().name)
-                            AsmAssignment(
-                                singleArg,
-                                AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, argDt, scope, argVarName),
-                                false, program.memsizer, target.position
-                            )
-                        }
-                    translateNormalAssignment(assignArgument)
-                }
-                if(targetStmt.shouldSaveX())
-                    saveRegisterLocal(CpuRegister.X, scope)
-                out("  jsr  ${asmSymbolName(target)}")
-                if(targetStmt.shouldSaveX())
-                    restoreRegisterLocal(CpuRegister.X)
-                return if(isStatement) DataType.UNDEFINED else targetStmt.returntypes.single()
-            }
-            else -> throw AssemblyError("invalid call target")
-        }
-    }
-
    internal fun popCpuStack(dt: DataType, target: VarDecl, scope: Subroutine?) {
        // note: because A is pushed first so popped last, saving A is often not required here.
        val parameter = target.subroutineParameter
@@ -3000,7 +2874,7 @@ $repeatLabel    lda  $counterVar
                }
            }
        } else {
-            val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, target.datatype, scope, variableAsmName = asmVariableName(target.name))
+            val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, this, target.datatype, scope, variableAsmName = asmVariableName(target.scopedName))
            if (dt in ByteDatatypes) {
                out("  pla")
                assignRegister(RegisterOrPair.A, tgt)
@@ -3028,6 +2902,9 @@ $repeatLabel    lda  $counterVar
        }
    }

+    internal fun needAsaveForExpr(arg: Expression): Boolean =
+        arg !is NumericLiteral && arg !is IdentifierReference && (arg !is DirectMemoryRead || !arg.isSimple)
+
    private val subroutineExtrasCache = mutableMapOf<Subroutine, SubroutineExtraAsmInfo>()

    internal fun subroutineExtra(sub: Subroutine): SubroutineExtraAsmInfo {
@@ -3,8 +3,8 @@ package prog8.codegen.cpu6502
 import com.github.michaelbull.result.Ok
 import com.github.michaelbull.result.Result
 import com.github.michaelbull.result.mapError
+import prog8.ast.generatedLabelPrefix
 import prog8.code.core.*
-import prog8.code.core.SourceCode
 import java.io.File
 import java.nio.file.Path
 import kotlin.io.path.Path
@@ -6,13 +6,11 @@ import prog8.ast.Program
 import prog8.ast.expressions.*
 import prog8.ast.statements.ArrayIndex
 import prog8.ast.statements.BuiltinFunctionCallStatement
-import prog8.ast.statements.DirectMemoryWrite
 import prog8.ast.statements.Subroutine
 import prog8.code.core.*
 import prog8.codegen.cpu6502.assignment.*
 import prog8.compiler.BuiltinFunctions
 import prog8.compiler.FSignature
-import prog8.compiler.builtinFunctionReturnType


 internal class BuiltinFunctionsAsmGen(private val program: Program,
@@ -30,43 +28,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
        translateFunctioncall(fcall, func, discardResult = true, resultToStack = false, resultRegister = null)
    }

-    internal fun translateUnaryFunctioncall(name: String, singleArg: AsmAssignSource, isStatement: Boolean, scope: Subroutine): DataType {
-        val func = BuiltinFunctions.getValue(name)
-        val argExpression =
-            when(singleArg.kind) {
-                SourceStorageKind.LITERALNUMBER -> singleArg.number!!
-                SourceStorageKind.EXPRESSION -> singleArg.expression!!
-                SourceStorageKind.ARRAY -> singleArg.array!!
-                else -> {
-                    // TODO make it so that we can assign efficiently from something else as an expression....namely: register(s)
-                    //      this is useful in pipe expressions for instance, to skip the use of a temporary variable
-                    //      but for now, just assign it to a temporary variable and use that as a source
-                    //      Idea: to do this without having to rewrite every single function in translateFunctioncall(),
-                    //            hack a special IdentifierReference like "!6502.A/X/Y/AX/AY/XY" to reference a cpu register
-                    val tempvar = asmgen.getTempVarName(singleArg.datatype)
-                    val assignTempvar = AsmAssignment(
-                        singleArg,
-                        AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, singleArg.datatype, scope, variableAsmName = asmgen.asmVariableName(tempvar)),
-                        false, program.memsizer, Position.DUMMY
-                    )
-                    assignAsmGen.translateNormalAssignment(assignTempvar)
-                    // now use an expression to assign this tempvar
-                    val ident = IdentifierReference(tempvar, Position.DUMMY)
-                    ident.linkParents(scope)
-                    ident
-                }
-            }
-        val argExpressions = mutableListOf(argExpression);
-        val fcall = BuiltinFunctionCall(IdentifierReference(listOf(name), Position.DUMMY), argExpressions, Position.DUMMY)
-        fcall.linkParents(scope)
-        translateFunctioncall(fcall, func, discardResult = false, resultToStack = false, null)
-        return if(isStatement) {
-            DataType.UNDEFINED
-        } else {
-            builtinFunctionReturnType(func.name, argExpressions, program).getOrElse { throw AssemblyError("unknown dt") }
-        }
-    }
-
    private fun translateFunctioncall(fcall: IFunctionCall, func: FSignature, discardResult: Boolean, resultToStack: Boolean, resultRegister: RegisterOrPair?) {
        if (discardResult && func.pure)
            return  // can just ignore the whole function call altogether
@@ -81,19 +42,8 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
            "lsb" -> funcLsb(fcall, resultToStack, resultRegister)
            "mkword" -> funcMkword(fcall, resultToStack, resultRegister)
            "abs" -> funcAbs(fcall, func, resultToStack, resultRegister, sscope)
-            "swap" -> funcSwap(fcall)
-            "min", "max" -> funcMinMax(fcall, func, resultToStack, resultRegister, sscope)
-            "sum" -> funcSum(fcall, resultToStack, resultRegister, sscope)
            "any", "all" -> funcAnyAll(fcall, func, resultToStack, resultRegister, sscope)
-            "sin8", "sin8u", "sin16", "sin16u",
-            "sinr8", "sinr8u", "sinr16", "sinr16u",
-            "cos8", "cos8u", "cos16", "cos16u",
-            "cosr8", "cosr8u", "cosr16", "cosr16u" -> funcSinCosInt(fcall, func, resultToStack, resultRegister, sscope)
            "sgn" -> funcSgn(fcall, func, resultToStack, resultRegister, sscope)
-            "sin", "cos", "tan", "atan",
-            "ln", "log2", "sqrt", "rad",
-            "deg", "round", "floor", "ceil",
-            "rndf" -> funcVariousFloatFuncs(fcall, func, resultToStack, resultRegister, sscope)
            "rnd", "rndw" -> funcRnd(func, resultToStack, resultRegister, sscope)
            "sqrt16" -> funcSqrt16(fcall, func, resultToStack, resultRegister, sscope)
            "rol" -> funcRol(fcall)
@@ -129,7 +79,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
            "cmp" -> funcCmp(fcall)
            "callfar" -> funcCallFar(fcall)
            "callrom" -> funcCallRom(fcall)
-            "syscall", "syscall1", "syscall2", "syscall3" -> throw AssemblyError("6502 assembly target doesn't use syscall function interface")
            else -> throw AssemblyError("missing asmgen for builtin func ${func.name}")
        }
    }
@@ -190,20 +139,19 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
            throw AssemblyError("callfar only works on cx16 target at this time")

        val bank = fcall.args[0].constValue(program)?.number?.toInt()
-        val address = fcall.args[1].constValue(program)?.number?.toInt()
-        if(bank==null || address==null)
-            throw AssemblyError("callfar (jsrfar) requires constant arguments")
-
-        if(address !in 0xa000..0xbfff)
-            throw AssemblyError("callfar done on address outside of cx16 banked ram")
-        if(bank==0)
-            throw AssemblyError("callfar done on bank 0 which is reserved for the kernal")
-
+        val address = fcall.args[1].constValue(program)?.number?.toInt() ?: 0
        val argAddrArg = fcall.args[2]
+        if(bank==null)
+            throw AssemblyError("callfar (jsrfar) bank has to be a constant")
+        if(fcall.args[1].constValue(program) == null) {
+            assignAsmGen.assignExpressionToRegister(fcall.args[1], RegisterOrPair.AY, false)
+            asmgen.out("  sta  (+)+0 |  sty  (+)+1  ; store jsrfar address word")
+        }
+
        if(argAddrArg.constValue(program)?.number == 0.0) {
            asmgen.out("""
                jsr  cx16.jsrfar
-                .word  ${address.toHex()}
+               .word  ${address.toHex()}
                .byte  ${bank.toHex()}""")
        } else {
            when(argAddrArg) {
@@ -213,7 +161,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                    asmgen.out("""
                        lda  ${asmgen.asmVariableName(argAddrArg.identifier)}
                        jsr  cx16.jsrfar
-                        .word  ${address.toHex()}
+                       .word  ${address.toHex()}
                        .byte  ${bank.toHex()}
                        sta  ${asmgen.asmVariableName(argAddrArg.identifier)}""")
                }
@@ -221,7 +169,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                    asmgen.out("""
                        lda  ${argAddrArg.number.toHex()}
                        jsr  cx16.jsrfar
-                        .word  ${address.toHex()}
+                       .word  ${address.toHex()}
                        .byte  ${bank.toHex()}
                        sta  ${argAddrArg.number.toHex()}""")
                }
@@ -391,23 +339,6 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
        }
    }

-    private fun funcSinCosInt(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        translateArguments(fcall.args, func, scope)
-        if(resultToStack)
-            asmgen.out("  jsr  prog8_lib.func_${func.name}_stack")
-        else
-            when(func.name) {
-                "sin8", "sin8u", "sinr8", "sinr8u", "cos8", "cos8u", "cosr8", "cosr8u" -> {
-                    asmgen.out("  jsr  prog8_lib.func_${func.name}_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
-                }
-                "sin16", "sin16u", "sinr16", "sinr16u", "cos16", "cos16u", "cosr16", "cosr16u" -> {
-                    asmgen.out("  jsr  prog8_lib.func_${func.name}_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-            }
-    }
-
    private fun funcReverse(fcall: IFunctionCall) {
        val variable = fcall.args.single()
        if (variable is IdentifierReference) {
@@ -539,6 +470,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                        } else {
                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.addressExpression)
                            if(ptrAndIndex!=null) {
+                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
                                asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
@@ -547,6 +479,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                                    sta  (+) + 1
                                    sty  (+) + 2
 +                                   ror  ${'$'}ffff,x           ; modified""")
+                                asmgen.restoreRegisterLocal(CpuRegister.X)
                            } else {
                                asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                                asmgen.out("""
@@ -640,6 +573,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                        } else {
                            val ptrAndIndex = asmgen.pointerViaIndexRegisterPossible(what.addressExpression)
                            if(ptrAndIndex!=null) {
+                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
                                asmgen.assignExpressionToRegister(ptrAndIndex.second, RegisterOrPair.X)
                                asmgen.saveRegisterLocal(CpuRegister.X, (fcall as Node).definingSubroutine!!)
                                asmgen.assignExpressionToRegister(ptrAndIndex.first, RegisterOrPair.AY)
@@ -648,6 +582,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
                                    sta  (+) + 1
                                    sty  (+) + 2
 +                                   rol  ${'$'}ffff,x           ; modified""")
+                                asmgen.restoreRegisterLocal(CpuRegister.X)
                            } else {
                                asmgen.assignExpressionToRegister(what.addressExpression, RegisterOrPair.AY)
                                asmgen.out("""
@@ -682,18 +617,14 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
    }

    private fun translateRolRorArrayArgs(arrayvar: IdentifierReference, indexer: ArrayIndex, operation: String, dt: Char) {
-        asmgen.assignExpressionToVariable(AddressOf(arrayvar, arrayvar.position), "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
-        asmgen.assignExpressionToVariable(indexer.indexExpr, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
-    }
-
-    private fun funcVariousFloatFuncs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        translateArguments(fcall.args, func, scope)
-        if(resultToStack)
-            asmgen.out("  jsr  floats.func_${func.name}_stack")
-        else {
-            asmgen.out("  jsr  floats.func_${func.name}_fac1")
-            assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, scope, program, asmgen))
+        if(arrayvar.targetVarDecl(program)!!.datatype==DataType.UWORD) {
+            if(dt!='b')
+                throw AssemblyError("non-array var indexing requires bytes dt")
+            asmgen.assignExpressionToVariable(arrayvar, "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
+        } else {
+            asmgen.assignExpressionToVariable(AddressOf(arrayvar, arrayvar.position), "prog8_lib.${operation}_array_u${dt}._arg_target", DataType.UWORD, null)
        }
+        asmgen.assignExpressionToVariable(indexer.indexExpr, "prog8_lib.${operation}_array_u${dt}._arg_index", DataType.UBYTE, null)
    }

    private fun funcSgn(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
@@ -733,538 +664,35 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
            }
        } else {
            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${function.name}_b_into_A")
-                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${function.name}_w_into_A")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${function.name}_f_into_A")
+                DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${function.name}_b_into_A |  ldy  #0")
+                DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${function.name}_w_into_A |  ldy  #0")
+                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${function.name}_f_into_A |  ldy  #0")
                else -> throw AssemblyError("weird type $dt")
            }
            assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
        }
    }

-    private fun funcMinMax(fcall: IFunctionCall, function: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        outputAddressAndLenghtOfArray(fcall.args[0])
-        val dt = fcall.args.single().inferType(program)
-        if(resultToStack) {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${function.name}_ub_stack")
-                DataType.ARRAY_B -> asmgen.out("  jsr  prog8_lib.func_${function.name}_b_stack")
-                DataType.ARRAY_UW -> asmgen.out("  jsr  prog8_lib.func_${function.name}_uw_stack")
-                DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${function.name}_w_stack")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_${function.name}_f_stack")
-                else -> throw AssemblyError("weird type $dt")
-            }
-        } else {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_UB, DataType.STR -> {
-                    asmgen.out("  jsr  prog8_lib.func_${function.name}_ub_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
-                }
-                DataType.ARRAY_B -> {
-                    asmgen.out("  jsr  prog8_lib.func_${function.name}_b_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
-                }
-                DataType.ARRAY_UW -> {
-                    asmgen.out("  jsr  prog8_lib.func_${function.name}_uw_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_W -> {
-                    asmgen.out("  jsr  prog8_lib.func_${function.name}_w_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_F -> {
-                    asmgen.out("  jsr  floats.func_${function.name}_f_fac1")
-                    assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, scope, program, asmgen))
-                }
-                else -> throw AssemblyError("weird type $dt")
-            }
-        }
-    }
-
-    private fun funcSum(fcall: IFunctionCall, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
-        outputAddressAndLenghtOfArray(fcall.args[0])
-        val dt = fcall.args.single().inferType(program)
-        if(resultToStack) {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_sum_ub_stack")
-                DataType.ARRAY_B -> asmgen.out("  jsr  prog8_lib.func_sum_b_stack")
-                DataType.ARRAY_UW -> asmgen.out("  jsr  prog8_lib.func_sum_uw_stack")
-                DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_sum_w_stack")
-                DataType.ARRAY_F -> asmgen.out("  jsr  floats.func_sum_f_stack")
-                else -> throw AssemblyError("weird type $dt")
-            }
-        } else {
-            when (dt.getOr(DataType.UNDEFINED)) {
-                DataType.ARRAY_UB, DataType.STR -> {
-                    asmgen.out("  jsr  prog8_lib.func_sum_ub_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_B -> {
-                    asmgen.out("  jsr  prog8_lib.func_sum_b_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_UW -> {
-                    asmgen.out("  jsr  prog8_lib.func_sum_uw_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_W -> {
-                    asmgen.out("  jsr  prog8_lib.func_sum_w_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.ARRAY_F -> {
-                    asmgen.out("  jsr  floats.func_sum_f_fac1")
-                    assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, scope, program, asmgen))
-                }
-                else -> throw AssemblyError("weird type $dt")
-            }
-        }
-    }
-
-    private fun funcSwap(fcall: IFunctionCall) {
-        val first = fcall.args[0]
-        val second = fcall.args[1]
-
-        // optimized simple case: swap two variables
-        if(first is IdentifierReference && second is IdentifierReference) {
-            val firstName = asmgen.asmVariableName(first)
-            val secondName = asmgen.asmVariableName(second)
-            val dt = first.inferType(program)
-            if(dt istype DataType.BYTE || dt istype DataType.UBYTE) {
-                asmgen.out(" ldy  $firstName |  lda  $secondName |  sta  $firstName |  sty  $secondName")
-                return
-            }
-            if(dt istype DataType.WORD || dt istype DataType.UWORD) {
-                asmgen.out("""
-                    ldy  $firstName
-                    lda  $secondName
-                    sta  $firstName
-                    sty  $secondName
-                    ldy  $firstName+1
-                    lda  $secondName+1
-                    sta  $firstName+1
-                    sty  $secondName+1
-                """)
-                return
-            }
-            if(dt istype DataType.FLOAT) {
-                asmgen.out("""
-                    lda  #<$firstName
-                    sta  P8ZP_SCRATCH_W1
-                    lda  #>$firstName
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  #<$secondName
-                    sta  P8ZP_SCRATCH_W2
-                    lda  #>$secondName
-                    sta  P8ZP_SCRATCH_W2+1
-                    jsr  floats.func_swap_f
-                """)
-                return
-            }
-        }
-
-        // optimized simple case: swap two memory locations
-        if(first is DirectMemoryRead && second is DirectMemoryRead) {
-            val addr1 = (first.addressExpression as? NumericLiteral)?.number?.toHex()
-            val addr2 = (second.addressExpression as? NumericLiteral)?.number?.toHex()
-            val name1 = if(first.addressExpression is IdentifierReference) asmgen.asmVariableName(first.addressExpression as IdentifierReference) else null
-            val name2 = if(second.addressExpression is IdentifierReference) asmgen.asmVariableName(second.addressExpression as IdentifierReference) else null
-
-            when {
-                addr1!=null && addr2!=null -> {
-                    asmgen.out("  ldy  $addr1 |  lda  $addr2 |  sta  $addr1 |  sty  $addr2")
-                    return
-                }
-                addr1!=null && name2!=null -> {
-                    asmgen.out("  ldy  $addr1 |  lda  $name2 |  sta  $addr1 |  sty  $name2")
-                    return
-                }
-                name1!=null && addr2 != null -> {
-                    asmgen.out("  ldy  $name1 |  lda  $addr2 |  sta  $name1 |  sty  $addr2")
-                    return
-                }
-                name1!=null && name2!=null -> {
-                    asmgen.out("  ldy  $name1 |  lda  $name2 |  sta  $name1 |  sty  $name2")
-                    return
-                }
-                addr1==null && addr2==null && name1==null && name2==null -> {
-                    val firstExpr = first.addressExpression as? BinaryExpression
-                    val secondExpr = second.addressExpression as? BinaryExpression
-                    if(firstExpr!=null && secondExpr!=null) {
-                        val pointerVariable = firstExpr.left as? IdentifierReference
-                        val firstOffset = firstExpr.right
-                        val secondOffset = secondExpr.right
-                        if(pointerVariable != null
-                            && pointerVariable isSameAs secondExpr.left
-                            && firstExpr.operator == "+" && secondExpr.operator == "+"
-                            && (firstOffset is NumericLiteral || firstOffset is IdentifierReference || firstOffset is TypecastExpression)
-                            && (secondOffset is NumericLiteral || secondOffset is IdentifierReference || secondOffset is TypecastExpression)
-                        ) {
-                            if(firstOffset is NumericLiteral && secondOffset is NumericLiteral) {
-                                if(firstOffset!=secondOffset) {
-                                    swapArrayValues(
-                                        DataType.UBYTE,
-                                        asmgen.asmVariableName(pointerVariable), firstOffset,
-                                        asmgen.asmVariableName(pointerVariable), secondOffset
-                                    )
-                                    return
-                                }
-                            } else if(firstOffset is TypecastExpression && secondOffset is TypecastExpression) {
-                                if(firstOffset.type in WordDatatypes && secondOffset.type in WordDatatypes) {
-                                    val firstOffsetVar = firstOffset.expression as? IdentifierReference
-                                    val secondOffsetVar = secondOffset.expression as? IdentifierReference
-                                    if(firstOffsetVar!=null && secondOffsetVar!=null) {
-                                        if(firstOffsetVar!=secondOffsetVar) {
-                                            swapArrayValues(
-                                                DataType.UBYTE,
-                                                asmgen.asmVariableName(pointerVariable), firstOffsetVar,
-                                                asmgen.asmVariableName(pointerVariable), secondOffsetVar
-                                            )
-                                            return
-                                        }
-                                    }
-                                }
-                            } else if(firstOffset is IdentifierReference || secondOffset is IdentifierReference) {
-                                throw AssemblyError("expected a typecast-to-word for index variable at ${firstOffset.position} and/or ${secondOffset.position}")
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        if(first is ArrayIndexedExpression && second is ArrayIndexedExpression) {
-            val arrayVarName1 = asmgen.asmVariableName(first.arrayvar)
-            val arrayVarName2 = asmgen.asmVariableName(second.arrayvar)
-            val elementIDt = first.inferType(program)
-            val elementDt = elementIDt.getOrElse { throw AssemblyError("unknown dt") }
-
-            val firstNum = first.indexer.indexExpr as? NumericLiteral
-            val firstVar = first.indexer.indexExpr as? IdentifierReference
-            val secondNum = second.indexer.indexExpr as? NumericLiteral
-            val secondVar = second.indexer.indexExpr as? IdentifierReference
-
-            if(firstNum!=null && secondNum!=null) {
-                swapArrayValues(elementDt, arrayVarName1, firstNum, arrayVarName2, secondNum)
-                return
-            } else if(firstVar!=null && secondVar!=null) {
-                swapArrayValues(elementDt, arrayVarName1, firstVar, arrayVarName2, secondVar)
-                return
-            } else if(firstNum!=null && secondVar!=null) {
-                swapArrayValues(elementDt, arrayVarName1, firstNum, arrayVarName2, secondVar)
-                return
-            } else if(firstVar!=null && secondNum!=null) {
-                swapArrayValues(elementDt, arrayVarName1, firstVar, arrayVarName2, secondNum)
-                return
-            }
-        }
-
-        // all other types of swap() calls are done via a temporary variable
-
-        fun targetFromExpr(expr: Expression, datatype: DataType): AsmAssignTarget {
-            return when (expr) {
-                is IdentifierReference -> AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, datatype, expr.definingSubroutine, variableAsmName = asmgen.asmVariableName(expr))
-                is ArrayIndexedExpression -> AsmAssignTarget(TargetStorageKind.ARRAY, program, asmgen, datatype, expr.definingSubroutine, array = expr)
-                is DirectMemoryRead -> AsmAssignTarget(TargetStorageKind.MEMORY, program, asmgen, datatype, expr.definingSubroutine, memory = DirectMemoryWrite(expr.addressExpression, expr.position))
-                else -> throw AssemblyError("invalid expression object $expr")
-            }
-        }
-
-        when(val datatype: DataType = first.inferType(program).getOr(DataType.UNDEFINED)) {
-            in ByteDatatypes, in WordDatatypes -> {
-                asmgen.assignExpressionToVariable(first, "P8ZP_SCRATCH_W1", datatype, null)
-                asmgen.assignExpressionToVariable(second, "P8ZP_SCRATCH_W2", datatype, null)
-                val assignFirst = AsmAssignment(
-                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W2"),
-                        targetFromExpr(first, datatype),
-                        false, program.memsizer, first.position
-                )
-                val assignSecond = AsmAssignment(
-                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, variableAsmName = "P8ZP_SCRATCH_W1"),
-                        targetFromExpr(second, datatype),
-                        false, program.memsizer, second.position
-                )
-                asmgen.translateNormalAssignment(assignFirst)
-                asmgen.translateNormalAssignment(assignSecond)
-            }
-            DataType.FLOAT -> {
-                // via temp variable and FAC1
-                asmgen.assignExpressionTo(first, AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, DataType.FLOAT, first.definingSubroutine, "floats.tempvar_swap_float"))
-                asmgen.assignExpressionTo(second, AsmAssignTarget(TargetStorageKind.REGISTER, program, asmgen, DataType.FLOAT, null, register=RegisterOrPair.FAC1))
-                asmgen.translateNormalAssignment(
-                    AsmAssignment(
-                        AsmAssignSource(SourceStorageKind.REGISTER, program, asmgen, datatype, register = RegisterOrPair.FAC1),
-                        targetFromExpr(first, datatype),
-                        false, program.memsizer, first.position
-                    )
-                )
-                asmgen.translateNormalAssignment(
-                    AsmAssignment(
-                        AsmAssignSource(SourceStorageKind.VARIABLE, program, asmgen, datatype, "floats.tempvar_swap_float"),
-                        targetFromExpr(second, datatype),
-                        false, program.memsizer, second.position
-                    )
-                )
-            }
-            else -> throw AssemblyError("weird swap dt")
-        }
-    }
-
-    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteral, arrayVarName2: String, indexValue2: NumericLiteral) {
-        val index1 = indexValue1.number.toInt() * program.memsizer.memorySize(elementDt)
-        val index2 = indexValue2.number.toInt() * program.memsizer.memorySize(elementDt)
-        when(elementDt) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("""
-                    lda  $arrayVarName1+$index1
-                    ldy  $arrayVarName2+$index2
-                    sta  $arrayVarName2+$index2
-                    sty  $arrayVarName1+$index1
-                """)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("""
-                    lda  $arrayVarName1+$index1
-                    ldy  $arrayVarName2+$index2
-                    sta  $arrayVarName2+$index2
-                    sty  $arrayVarName1+$index1
-                    lda  $arrayVarName1+$index1+1
-                    ldy  $arrayVarName2+$index2+1
-                    sta  $arrayVarName2+$index2+1
-                    sty  $arrayVarName1+$index1+1
-                """)
-            }
-            DataType.FLOAT -> {
-                asmgen.out("""
-                    lda  #<(${arrayVarName1}+$index1)
-                    sta  P8ZP_SCRATCH_W1
-                    lda  #>(${arrayVarName1}+$index1)
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  #<(${arrayVarName2}+$index2)
-                    sta  P8ZP_SCRATCH_W2
-                    lda  #>(${arrayVarName2}+$index2)
-                    sta  P8ZP_SCRATCH_W2+1
-                    jsr  floats.func_swap_f
-                """)
-            }
-            else -> throw AssemblyError("invalid aray elt type")
-        }
-    }
-
-    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexName2: IdentifierReference) {
-        val idxAsmName1 = asmgen.asmVariableName(indexName1)
-        val idxAsmName2 = asmgen.asmVariableName(indexName2)
-        when(elementDt) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG
-                    ldx  $idxAsmName1
-                    ldy  $idxAsmName2
-                    lda  $arrayVarName1,x
-                    pha
-                    lda  $arrayVarName2,y
-                    sta  $arrayVarName1,x
-                    pla
-                    sta  $arrayVarName2,y
-                    ldx  P8ZP_SCRATCH_REG
-                """)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("""
-                    stx  P8ZP_SCRATCH_REG
-                    lda  $idxAsmName1
-                    asl  a
-                    tax
-                    lda  $idxAsmName2
-                    asl  a
-                    tay
-                    lda  $arrayVarName1,x
-                    pha
-                    lda  $arrayVarName2,y
-                    sta  $arrayVarName1,x
-                    pla
-                    sta  $arrayVarName2,y
-                    lda  $arrayVarName1+1,x
-                    pha
-                    lda  $arrayVarName2+1,y
-                    sta  $arrayVarName1+1,x
-                    pla
-                    sta  $arrayVarName2+1,y
-                    ldx  P8ZP_SCRATCH_REG
-                """)
-            }
-            DataType.FLOAT -> {
-                asmgen.out("""
-                    lda  #>$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  $idxAsmName1
-                    asl  a
-                    asl  a
-                    clc
-                    adc  $idxAsmName1
-                    adc  #<$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1
-                    bcc  +
-                    inc  P8ZP_SCRATCH_W1+1
-+                   lda  #>$arrayVarName2
-                    sta  P8ZP_SCRATCH_W2+1
-                    lda  $idxAsmName2
-                    asl  a
-                    asl  a
-                    clc
-                    adc  $idxAsmName2
-                    adc  #<$arrayVarName2
-                    sta  P8ZP_SCRATCH_W2
-                    bcc  +
-                    inc  P8ZP_SCRATCH_W2+1
-+                   jsr  floats.func_swap_f                                   
-                """)
-            }
-            else -> throw AssemblyError("invalid aray elt type")
-        }
-    }
-
-    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexValue1: NumericLiteral, arrayVarName2: String, indexName2: IdentifierReference) {
-        val index1 = indexValue1.number.toInt() * program.memsizer.memorySize(elementDt)
-        val idxAsmName2 = asmgen.asmVariableName(indexName2)
-        when(elementDt) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("""
-                    lda  $arrayVarName1 + $index1
-                    pha
-                    ldy  $idxAsmName2
-                    lda  $arrayVarName2,y
-                    sta  $arrayVarName1 + $index1
-                    pla
-                    sta  $arrayVarName2,y
-                """)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("""
-                    lda  $arrayVarName1 + $index1
-                    pha
-                    lda  $idxAsmName2
-                    asl  a
-                    tay
-                    lda  $arrayVarName2,y
-                    sta  $arrayVarName1 + $index1
-                    pla
-                    sta  $arrayVarName2,y
-                    lda  $arrayVarName1 + $index1+1
-                    pha
-                    lda  $arrayVarName2+1,y
-                    sta  $arrayVarName1 + $index1+1
-                    pla
-                    sta  $arrayVarName2+1,y
-                """)
-            }
-            DataType.FLOAT -> {
-                asmgen.out("""
-                    lda  #<(${arrayVarName1}+$index1)
-                    sta  P8ZP_SCRATCH_W1
-                    lda  #>(${arrayVarName1}+$index1)
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  #>$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  $idxAsmName2
-                    asl  a
-                    asl  a
-                    clc
-                    adc  $idxAsmName2
-                    adc  #<$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1
-                    bcc  +
-                    inc  P8ZP_SCRATCH_W1+1
-+                   jsr  floats.func_swap_f
-                """)
-            }
-            else -> throw AssemblyError("invalid aray elt type")
-        }
-    }
-
-    private fun swapArrayValues(elementDt: DataType, arrayVarName1: String, indexName1: IdentifierReference, arrayVarName2: String, indexValue2: NumericLiteral) {
-        val idxAsmName1 = asmgen.asmVariableName(indexName1)
-        val index2 = indexValue2.number.toInt() * program.memsizer.memorySize(elementDt)
-        when(elementDt) {
-            DataType.UBYTE, DataType.BYTE -> {
-                asmgen.out("""
-                    lda  $arrayVarName2 + $index2
-                    pha
-                    ldy  $idxAsmName1
-                    lda  $arrayVarName1,y
-                    sta  $arrayVarName2 + $index2
-                    pla
-                    sta  $arrayVarName1,y
-                """)
-            }
-            DataType.UWORD, DataType.WORD -> {
-                asmgen.out("""
-                    lda  $arrayVarName2 + $index2
-                    pha
-                    lda  $idxAsmName1
-                    asl  a
-                    tay
-                    lda  $arrayVarName1,y
-                    sta  $arrayVarName2 + $index2
-                    pla
-                    sta  $arrayVarName1,y
-                    lda  $arrayVarName2 + $index2+1
-                    pha
-                    lda  $arrayVarName1+1,y
-                    sta  $arrayVarName2 + $index2+1
-                    pla
-                    sta  $arrayVarName1+1,y
-                """)
-            }
-            DataType.FLOAT -> {
-                asmgen.out("""
-                    lda  #>$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1+1
-                    lda  $idxAsmName1
-                    asl  a
-                    asl  a
-                    clc
-                    adc  $idxAsmName1
-                    adc  #<$arrayVarName1
-                    sta  P8ZP_SCRATCH_W1
-                    bcc  +
-                    inc  P8ZP_SCRATCH_W1+1
-+                   lda  #<(${arrayVarName2}+$index2)
-                    sta  P8ZP_SCRATCH_W2
-                    lda  #>(${arrayVarName2}+$index2)
-                    sta  P8ZP_SCRATCH_W2+1
-                    jsr  floats.func_swap_f
-                """)
-            }
-            else -> throw AssemblyError("invalid aray elt type")
-        }
-    }
-
    private fun funcAbs(fcall: IFunctionCall, func: FSignature, resultToStack: Boolean, resultRegister: RegisterOrPair?, scope: Subroutine?) {
        translateArguments(fcall.args, func, scope)
        val dt = fcall.args.single().inferType(program).getOr(DataType.UNDEFINED)
        if(resultToStack) {
            when (dt) {
-                in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.abs_b_stack")
-                in WordDatatypes -> asmgen.out("  jsr  prog8_lib.abs_w_stack")
-                DataType.FLOAT -> asmgen.out("  jsr  floats.abs_f_stack")
+                DataType.UBYTE -> asmgen.out("  ldy  #0")
+                DataType.BYTE -> asmgen.out("  jsr  prog8_lib.abs_b_stack")
+                DataType.UWORD -> {}
+                DataType.WORD -> asmgen.out("  jsr  prog8_lib.abs_w_stack")
                else -> throw AssemblyError("weird type")
            }
        } else {
            when (dt) {
-                in ByteDatatypes -> {
-                    asmgen.out("  jsr  prog8_lib.abs_b_into_A")
-                    assignAsmGen.assignRegisterByte(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.A, false, scope, program, asmgen), CpuRegister.A)
-                }
-                in WordDatatypes -> {
-                    asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
-                    assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
-                }
-                DataType.FLOAT -> {
-                    asmgen.out("  jsr  floats.abs_f_fac1")
-                    assignAsmGen.assignFAC1float(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.FAC1, true, scope, program, asmgen))
-                }
+                DataType.UBYTE -> asmgen.out("  ldy  #0")
+                DataType.BYTE -> asmgen.out("  jsr  prog8_lib.abs_b_into_AY")
+                DataType.UWORD -> {}
+                DataType.WORD -> asmgen.out("  jsr  prog8_lib.abs_w_into_AY")
                else -> throw AssemblyError("weird type")
            }
+            assignAsmGen.assignRegisterpairWord(AsmAssignTarget.fromRegisters(resultRegister ?: RegisterOrPair.AY, false, scope, program, asmgen), RegisterOrPair.AY)
        }
    }

@@ -1432,12 +860,12 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
            asmgen.out("  sta  P8ESTACK_LO,x |  tya |  sta  P8ESTACK_HI,x |  dex")
        } else {
            val reg = resultRegister ?: RegisterOrPair.AY
-            var needAsave = !(fcall.args[0] is DirectMemoryRead || fcall.args[0] is NumericLiteral || fcall.args[0] is IdentifierReference)
+            var needAsave = asmgen.needAsaveForExpr(fcall.args[0])
            if(!needAsave) {
                val mr0 = fcall.args[0] as? DirectMemoryRead
                val mr1 = fcall.args[1] as? DirectMemoryRead
                if (mr0 != null)
-                    needAsave = mr0.addressExpression !is NumericLiteral && mr0.addressExpression !is IdentifierReference
+                    needAsave =  mr0.addressExpression !is NumericLiteral && mr0.addressExpression !is IdentifierReference
                if (mr1 != null)
                    needAsave = needAsave or (mr1.addressExpression !is NumericLiteral && mr1.addressExpression !is IdentifierReference)
            }
@@ -1596,8 +1024,11 @@ internal class BuiltinFunctionsAsmGen(private val program: Program,
    private fun outputAddressAndLenghtOfArray(arg: Expression) {
        // address in P8ZP_SCRATCH_W1,  number of elements in A
        arg as IdentifierReference
+        val arrayVar = arg.targetVarDecl(program)!!
+        if(!arrayVar.isArray)
+            throw AssemblyError("length of non-array requested")
+        val size = arrayVar.arraysize!!.constIndex()!!
        val identifierName = asmgen.asmVariableName(arg)
-        val size = arg.targetVarDecl(program)!!.arraysize!!.constIndex()!!
        asmgen.out("""
                    lda  #<$identifierName
                    ldy  #>$identifierName
@@ -34,8 +34,6 @@ internal class ExpressionsAsmGen(private val program: Program,
            is IdentifierReference -> translateExpression(expression)
            is FunctionCallExpression -> translateFunctionCallResultOntoStack(expression)
            is BuiltinFunctionCall -> asmgen.translateBuiltinFunctionCallExpression(expression, true, null)
-            is PipeExpression -> asmgen.translatePipeExpression(expression.source, expression.segments,
-                                                                expression, isStatement = false, pushResultOnEstack = true )
            is ContainmentCheck -> throw AssemblyError("containment check as complex expression value is not supported")
            is ArrayLiteral, is StringLiteral -> throw AssemblyError("no asm gen for string/array literal value assignment - should have been replaced by a variable")
            is RangeExpression -> throw AssemblyError("range expression should have been changed into array values")
@@ -138,7 +136,7 @@ internal class ExpressionsAsmGen(private val program: Program,
    private fun translateExpression(typecast: TypecastExpression) {
        translateExpressionInternal(typecast.expression)
        when(typecast.expression.inferType(program).getOr(DataType.UNDEFINED)) {
-            DataType.UBYTE -> {
+            DataType.UBYTE, DataType.BOOL -> {
                when(typecast.type) {
                    DataType.UBYTE, DataType.BYTE -> {}
                    DataType.UWORD, DataType.WORD -> {
@@ -534,8 +532,8 @@ internal class ExpressionsAsmGen(private val program: Program,
            }
            in ComparisonOperators -> {
                if(leftDt in NumericDatatypes && rightDt in NumericDatatypes) {
-                    val rightVal = expr.right.constValue(program)?.number?.toInt()
-                    if(rightVal==0)
+                    val rightVal = expr.right.constValue(program)?.number
+                    if(rightVal==0.0)
                        return translateComparisonWithZero(expr.left, leftDt, expr.operator)
                }
            }
@@ -562,6 +560,42 @@ internal class ExpressionsAsmGen(private val program: Program,
    }

    private fun translateComparisonWithZero(expr: Expression, dt: DataType, operator: String) {
+        if(expr.isSimple) {
+            if(operator=="!=") {
+                when (dt) {
+                    in ByteDatatypes -> {
+                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.A, dt == DataType.BYTE)
+                        asmgen.out("""
+                            beq  +
+                            lda  #1
+                           sta  P8ESTACK_LO,x
+                            dex""")
+                        return
+                    }
+                    in WordDatatypes -> {
+                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.AY, dt == DataType.WORD)
+                        asmgen.out("""
+                            sty  P8ZP_SCRATCH_B1 
+                            ora  P8ZP_SCRATCH_B1
+                            beq  +
+                            lda  #1
+                           sta  P8ESTACK_LO,x
+                            dex""")
+                        return
+                    }
+                    DataType.FLOAT -> {
+                        asmgen.assignExpressionToRegister(expr, RegisterOrPair.FAC1, true)
+                        asmgen.out("""
+                            jsr  floats.SIGN
+                            sta  P8ESTACK_LO,x
+                            dex""")
+                        return
+                    }
+                    else -> {}
+                }
+            }
+            /* operator == is not worth it to special case, the code is mostly larger */
+        }
        translateExpressionInternal(expr)
        when(operator) {
            "==" -> {
@@ -666,22 +700,6 @@ internal class ExpressionsAsmGen(private val program: Program,
                    else -> throw AssemblyError("weird type")
                }
            }
-            "not" -> {
-                when(type) {
-                    // if reg==0 ->
-                    /*
-        lda  P8ESTACK_LO+1,x
-		beq  +
-		lda  #1
-+		eor  #1
-		sta  P8ESTACK_LO+1,x
-		rts
-                     */
-                    in ByteDatatypes -> asmgen.out("  jsr  prog8_lib.not_byte")
-                    in WordDatatypes -> asmgen.out("  jsr  prog8_lib.not_word")
-                    else -> throw AssemblyError("weird type")
-                }
-            }
            else -> throw AssemblyError("invalid prefix operator ${expr.operator}")
        }
    }
@@ -692,6 +710,25 @@ internal class ExpressionsAsmGen(private val program: Program,
            throw AssemblyError("unknown dt")
        val elementDt = elementIDt.getOr(DataType.UNDEFINED)
        val arrayVarName = asmgen.asmVariableName(arrayExpr.arrayvar)
+
+        val arrayVarDecl = arrayExpr.arrayvar.targetVarDecl(program)!!
+        if(arrayVarDecl.datatype==DataType.UWORD) {
+            // indexing a pointer var instead of a real array or string
+            if(elementDt !in ByteDatatypes)
+                throw AssemblyError("non-array var indexing requires bytes dt")
+            if(arrayExpr.inferType(program) isnot DataType.UBYTE)
+                throw AssemblyError("non-array var indexing requires bytes index")
+            asmgen.loadScaledArrayIndexIntoRegister(arrayExpr, elementDt, CpuRegister.Y)
+            if(asmgen.isZpVar(arrayExpr.arrayvar)) {
+                asmgen.out("  lda  ($arrayVarName),y")
+            } else {
+                asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
+                asmgen.out("  lda  (P8ZP_SCRATCH_W1),y")
+            }
+            asmgen.out("  sta  P8ESTACK_LO,x |  dex")
+            return
+        }
+
        val constIndexNum = arrayExpr.indexer.constIndex()
        if(constIndexNum!=null) {
            val indexValue = constIndexNum * program.memsizer.memorySize(elementDt)
@@ -767,9 +804,6 @@ internal class ExpressionsAsmGen(private val program: Program,
            "&" -> asmgen.out("  jsr  prog8_lib.bitand_b")
            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_b")
            "|" -> asmgen.out("  jsr  prog8_lib.bitor_b")
-            "and" -> asmgen.out("  jsr  prog8_lib.and_b")
-            "or" -> asmgen.out("  jsr  prog8_lib.or_b")
-            "xor" -> asmgen.out("  jsr  prog8_lib.xor_b")
            else -> throw AssemblyError("invalid operator $operator")
        }
    }
@@ -801,9 +835,6 @@ internal class ExpressionsAsmGen(private val program: Program,
            "&" -> asmgen.out("  jsr  prog8_lib.bitand_w")
            "^" -> asmgen.out("  jsr  prog8_lib.bitxor_w")
            "|" -> asmgen.out("  jsr  prog8_lib.bitor_w")
-            "and" -> asmgen.out("  jsr  prog8_lib.and_w")
-            "or" -> asmgen.out("  jsr  prog8_lib.or_w")
-            "xor" -> asmgen.out("  jsr  prog8_lib.xor_w")
            else -> throw AssemblyError("invalid operator $operator")
        }
    }
@@ -820,7 +851,7 @@ internal class ExpressionsAsmGen(private val program: Program,
            ">=" -> asmgen.out("  jsr  floats.greatereq_f")
            "==" -> asmgen.out("  jsr  floats.equal_f")
            "!=" -> asmgen.out("  jsr  floats.notequal_f")
-            "%", "<<", ">>", "&", "^", "|", "and", "or", "xor" -> throw AssemblyError("requires integer datatype")
+            "%", "<<", ">>", "&", "^", "|" -> throw AssemblyError("requires integer datatype")
            else -> throw AssemblyError("invalid operator $operator")
        }
    }
@@ -31,10 +31,10 @@ internal class ForLoopsAsmGen(private val program: Program, private val asmgen:
    }

    private fun translateForOverNonconstRange(stmt: ForLoop, iterableDt: DataType, range: RangeExpression) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
-        val modifiedLabel = asmgen.makeLabel("for_modified")
-        val modifiedLabel2 = asmgen.makeLabel("for_modifiedb")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
+        val modifiedLabel = program.makeLabel("for_modified")
+        val modifiedLabel2 = program.makeLabel("for_modifiedb")
        asmgen.loopEndLabels.push(endLabel)
        val stepsize=range.step.constValue(program)!!.number.toInt()

@@ -238,8 +238,8 @@ $endLabel""")
    }

    private fun translateForOverIterableVar(stmt: ForLoop, iterableDt: DataType, ident: IdentifierReference) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        val iterableName = asmgen.asmVariableName(ident)
        val decl = ident.targetVarDecl(program)!!
@@ -263,7 +263,7 @@ $endLabel""")
            }
            DataType.ARRAY_UB, DataType.ARRAY_B -> {
                val length = decl.arraysize!!.constIndex()!!
-                val indexVar = asmgen.makeLabel("for_index")
+                val indexVar = program.makeLabel("for_index")
                asmgen.out("""
                    ldy  #0
 $loopLabel          sty  $indexVar
@@ -299,7 +299,7 @@ $loopLabel          sty  $indexVar
            }
            DataType.ARRAY_W, DataType.ARRAY_UW -> {
                val length = decl.arraysize!!.constIndex()!! * 2
-                val indexVar = asmgen.makeLabel("for_index")
+                val indexVar = program.makeLabel("for_index")
                val loopvarName = asmgen.asmVariableName(stmt.loopVar)
                asmgen.out("""
                    ldy  #0
@@ -359,8 +359,8 @@ $loopLabel          sty  $indexVar
        }

        // not one of the easy cases, generate more complex code...
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        when(iterableDt) {
            DataType.ARRAY_B, DataType.ARRAY_UB -> {
@@ -471,8 +471,8 @@ $loopLabel""")
    }

    private fun translateForSimpleByteRangeAsc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        val varname = asmgen.asmVariableName(stmt.loopVar)
        asmgen.out("""
@@ -497,8 +497,8 @@ $endLabel""")
    }

    private fun translateForSimpleByteRangeDesc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        val varname = asmgen.asmVariableName(stmt.loopVar)
        asmgen.out("""
@@ -534,8 +534,8 @@ $endLabel""")
    }

    private fun translateForSimpleWordRangeAsc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        val varname = asmgen.asmVariableName(stmt.loopVar)
        asmgen.out("""
@@ -561,8 +561,8 @@ $loopLabel""")
    }

    private fun translateForSimpleWordRangeDesc(stmt: ForLoop, range: IntProgression) {
-        val loopLabel = asmgen.makeLabel("for_loop")
-        val endLabel = asmgen.makeLabel("for_end")
+        val loopLabel = program.makeLabel("for_loop")
+        val endLabel = program.makeLabel("for_end")
        asmgen.loopEndLabels.push(endLabel)
        val varname = asmgen.asmVariableName(stmt.loopVar)
        asmgen.out("""
@@ -111,10 +111,10 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
                } else {
                    // 2 byte params, second in Y, first in A
                    argumentViaRegister(sub, IndexedValue(0, sub.parameters[0]), call.args[0], RegisterOrPair.A)
-                    if(!call.args[1].isSimple)
+                    if(asmgen.needAsaveForExpr(call.args[1]))
                        asmgen.out("  pha")
                    argumentViaRegister(sub, IndexedValue(1, sub.parameters[1]), call.args[1], RegisterOrPair.Y)
-                    if(!call.args[1].isSimple)
+                    if(asmgen.needAsaveForExpr(call.args[1]))
                        asmgen.out("  pla")
                }
            } else {
@@ -159,7 +159,7 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
        }
        argOrder.forEach {
            val param = callee.parameters[it]
-            val targetVar = callee.searchAsmParameter(param.name)!!
+            val targetVar = callee.searchParameter(param.name)!!
            asmgen.popCpuStack(param.type, targetVar, (call as Node).definingSubroutine)
        }
    }
@@ -1,7 +1,6 @@
 package prog8.codegen.cpu6502

 import prog8.ast.Program
-import prog8.ast.antlr.escape
 import prog8.ast.statements.*
 import prog8.code.*
 import prog8.code.core.*
@@ -71,8 +70,17 @@ internal class ProgramAndVarsGen(
        asmgen.out("P8ZP_SCRATCH_REG = ${zp.SCRATCH_REG}")
        asmgen.out("P8ZP_SCRATCH_W1 = ${zp.SCRATCH_W1}    ; word")
        asmgen.out("P8ZP_SCRATCH_W2 = ${zp.SCRATCH_W2}    ; word")
+        asmgen.out(".weak")   // hack to allow user to override the following two with command line redefinition (however, just use '-esa' command line option instead!)
        asmgen.out("P8ESTACK_LO = ${compTarget.machine.ESTACK_LO.toHex()}")
        asmgen.out("P8ESTACK_HI = ${compTarget.machine.ESTACK_HI.toHex()}")
+        asmgen.out(".endweak")
+
+        if(options.symbolDefs.isNotEmpty()) {
+            asmgen.out("; -- user supplied symbols on the command line")
+            for((name, value) in options.symbolDefs) {
+                asmgen.out("$name = $value")
+            }
+        }

        when(options.output) {
            OutputType.RAW -> {
@@ -128,9 +136,24 @@ internal class ProgramAndVarsGen(
            "cx16" -> {
                if(options.floats)
                    asmgen.out("  lda  #4 |  sta  $01")    // to use floats, make sure Basic rom is banked in
-                asmgen.out("  jsr  main.start |  lda  #4 |  sta  $01 |  rts")
+                asmgen.out("  jsr  main.start")
+                asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
+            }
+            "c64" -> {
+                asmgen.out("  jsr  main.start |  lda  #31 |  sta  $01")
+                if(!options.noSysInit)
+                    asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
+                else
+                    asmgen.out("  rts")
+            }
+            "c128" -> {
+                asmgen.out("  jsr  main.start")
+                // TODO c128: how to bank basic+kernal back in?
+                if(!options.noSysInit)
+                    asmgen.out("  jmp  ${compTarget.name}.cleanup_at_exit")
+                else
+                    asmgen.out("  rts")
            }
-            "c64" -> asmgen.out("  jsr  main.start |  lda  #31 |  sta  $01 |  rts")
            else -> asmgen.jmp("main.start")
        }
    }
@@ -572,7 +595,7 @@ internal class ProgramAndVarsGen(
    }

    private fun outputStringvar(varname: String, encoding: Encoding, value: String) {
-        asmgen.out("$varname\t; $encoding:\"${escape(value).replace("\u0000", "<NULL>")}\"")
+        asmgen.out("$varname\t; $encoding:\"${value.escape().replace("\u0000", "<NULL>")}\"", false)
        val bytes = compTarget.encodeString(value, encoding).plus(0.toUByte())
        val outputBytes = bytes.map { "$" + it.toString(16).padStart(2, '0') }
        for (chunk in outputBytes.chunked(16))
@@ -116,9 +116,9 @@ internal class VariableAllocator(private val symboltable: SymbolTable,
            }
        }

-        println("  number of allocated vars: $numberOfAllocatableVariables")
-        println("  put into zeropage: $numVariablesAllocatedInZP,  non-zp allocatable: ${numberOfNonIntegerVariables+numberOfExplicitNonZpVariables}")
-        println("  zeropage free space: ${zeropage.free.size} bytes")
+//        println("  number of allocated vars: $numberOfAllocatableVariables")
+//        println("  put into zeropage: $numVariablesAllocatedInZP,  non-zp allocatable: ${numberOfNonIntegerVariables+numberOfExplicitNonZpVariables}")
+//        println("  zeropage free space: ${zeropage.free.size} bytes")
    }

    private fun collectAllVariables(st: SymbolTable): Collection<StStaticVariable> {
@@ -2,7 +2,10 @@ package prog8.codegen.cpu6502.assignment

 import prog8.ast.Program
 import prog8.ast.expressions.*
-import prog8.ast.statements.*
+import prog8.ast.statements.AssignTarget
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.DirectMemoryWrite
+import prog8.ast.statements.Subroutine
 import prog8.code.core.*
 import prog8.codegen.cpu6502.AsmGen

@@ -37,7 +40,6 @@ internal class AsmAssignTarget(val kind: TargetStorageKind,
                               val origAstTarget: AssignTarget? = null
                               )
 {
-    val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toUInt() ?: 0u}
    val constArrayIndexValue by lazy { array?.indexer?.constIndex()?.toUInt() }
    val asmVarname: String by lazy {
        if (array == null)
@@ -122,9 +124,6 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
                               val expression: Expression? = null
 )
 {
-    val constMemoryAddress by lazy { memory?.addressExpression?.constValue(program)?.number?.toUInt() ?: 0u}
-    val constArrayIndexValue by lazy { array?.indexer?.constIndex()?.toUInt() }
-
    val asmVarname: String
        get() = if(array==null)
            variableAsmName!!
@@ -132,8 +131,6 @@ internal class AsmAssignSource(val kind: SourceStorageKind,
            asmgen.asmVariableName(array.arrayvar)

    companion object {
-        fun fromAstSource(indexer: ArrayIndex, program: Program, asmgen: AsmGen): AsmAssignSource = fromAstSource(indexer.indexExpr, program, asmgen)
-
        fun fromAstSource(value: Expression, program: Program, asmgen: AsmGen): AsmAssignSource {
            val cv = value.constValue(program)
            if(cv!=null)
@@ -72,6 +72,25 @@ internal class AssignmentAsmGen(private val program: Program,
                val value = assign.source.array!!
                val elementDt = assign.source.datatype
                val arrayVarName = asmgen.asmVariableName(value.arrayvar)
+
+                val arrayVarDecl = value.arrayvar.targetVarDecl(program)!!
+                if(arrayVarDecl.datatype==DataType.UWORD) {
+                    // indexing a pointer var instead of a real array or string
+                    if(elementDt !in ByteDatatypes)
+                        throw AssemblyError("non-array var indexing requires bytes dt")
+                    if(value.inferType(program) isnot DataType.UBYTE)
+                        throw AssemblyError("non-array var indexing requires bytes index")
+                    asmgen.loadScaledArrayIndexIntoRegister(value, elementDt, CpuRegister.Y)
+                    if(asmgen.isZpVar(value.arrayvar)) {
+                        asmgen.out("  lda  ($arrayVarName),y")
+                    } else {
+                        asmgen.out("  lda  $arrayVarName |  sta  P8ZP_SCRATCH_W1 |  lda  $arrayVarName+1 |  sta  P8ZP_SCRATCH_W1+1")
+                        asmgen.out("  lda  (P8ZP_SCRATCH_W1),y")
+                    }
+                    assignRegisterByte(assign.target, CpuRegister.A)
+                    return
+                }
+
                val constIndex = value.indexer.constIndex()
                if (constIndex!=null) {
                    // constant array index value
@@ -185,15 +204,7 @@ internal class AssignmentAsmGen(private val program: Program,
                                assignRegisterpairWord(assign.target, RegisterOrPair.AY)
                            }
                            DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B -> {
-                                // copy the actual string result into the target string variable
-                                asmgen.out("""
-                                            pha
-                                            lda  #<${assign.target.asmVarname}
-                                            sta  P8ZP_SCRATCH_W1
-                                            lda  #>${assign.target.asmVarname}
-                                            sta  P8ZP_SCRATCH_W1+1
-                                            pla
-                                            jsr  prog8_lib.strcpy""")
+                                throw AssemblyError("stringvalue assignment should have been replaced by a call to strcpy")
                            }
                            else -> throw AssemblyError("weird target dt")
                        }
@@ -229,7 +240,7 @@ internal class AssignmentAsmGen(private val program: Program,
                asmgen.translateBuiltinFunctionCallExpression(value, false, assign.target.register)
                if(assign.target.register==null) {
                    // still need to assign the result to the target variable/etc.
-                    val returntype = builtinFunctionReturnType(value.name, value.args, program)
+                    val returntype = builtinFunctionReturnType(value.name)
                    if(!returntype.isKnown)
                        throw AssemblyError("unknown dt")
                    when(returntype.getOr(DataType.UNDEFINED)) {
@@ -271,7 +282,6 @@ internal class AssignmentAsmGen(private val program: Program,
                    "+" -> {}
                    "-" -> augmentableAsmGen.inplaceNegate(target, target.datatype)
                    "~" -> augmentableAsmGen.inplaceInvert(target, target.datatype)
-                    "not" -> augmentableAsmGen.inplaceBooleanNot(target, target.datatype)
                    else -> throw AssemblyError("invalid prefix operator")
                }
            }
@@ -279,35 +289,8 @@ internal class AssignmentAsmGen(private val program: Program,
                containmentCheckIntoA(value)
                assignRegisterByte(assign.target, CpuRegister.A)
            }
-            is PipeExpression -> {
-                asmgen.translatePipeExpression(value.source, value.segments, value, false, false)
-                val resultDt = value.inferType(program)
-                val register =
-                    if(resultDt.isBytes) RegisterOrPair.A
-                    else if(resultDt.isWords) RegisterOrPair.AY
-                    else if(resultDt istype DataType.FLOAT) RegisterOrPair.FAC1
-                    else throw AssemblyError("invalid dt")
-                asmgen.assignRegister(register, assign.target)
-            }
            is BinaryExpression -> {
-                if(value.operator in ComparisonOperators) {
-                    // TODO real optimized code for comparison expressions that yield a boolean result value
-                    assignConstantByte(assign.target, 0)
-                    val origTarget = assign.target.origAstTarget
-                    if(origTarget!=null) {
-                        val assignTrue = AnonymousScope(mutableListOf(
-                            Assignment(origTarget, NumericLiteral.fromBoolean(true, assign.position), AssignmentOrigin.ASMGEN, assign.position)
-                        ), assign.position)
-                        val assignFalse = AnonymousScope(mutableListOf(), assign.position)
-                        val ifelse = IfElse(value.copy(), assignTrue, assignFalse, assign.position)
-                        ifelse.linkParents(value)
-                        asmgen.translate(ifelse)
-                    }
-                    else {
-                        // no orig ast assign target so can't use the workaround, so fallback to stack eval
-                        fallbackToStackEval(assign)
-                    }
-                } else {
+                if(!attemptAssignOptimizedBinexpr(value, assign)) {
                    // All remaining binary expressions just evaluate via the stack for now.
                    // (we can't use the assignment helper functions (assignExpressionTo...) to do it via registers here,
                    // because the code here is the implementation of exactly that...)
@@ -318,6 +301,240 @@ internal class AssignmentAsmGen(private val program: Program,
        }
    }

+    private fun attemptAssignOptimizedBinexpr(expr: BinaryExpression, assign: AsmAssignment): Boolean {
+        if(expr.operator in ComparisonOperators) {
+            if(expr.right.constValue(program)?.number == 0.0) {
+                if(expr.operator == "==" || expr.operator=="!=") {
+                    when(assign.target.datatype) {
+                        in ByteDatatypes -> if(attemptAssignToByteCompareZero(expr, assign)) return true
+                        else -> {
+                            // do nothing, this is handled by a type cast.
+                        }
+                    }
+                }
+            }
+            val origTarget = assign.target.origAstTarget
+            if(origTarget!=null) {
+                assignConstantByte(assign.target, 0)
+                val assignTrue = AnonymousScope(mutableListOf(
+                    Assignment(origTarget, NumericLiteral.fromBoolean(true, assign.position), AssignmentOrigin.ASMGEN, assign.position)
+                ), assign.position)
+                val assignFalse = AnonymousScope(mutableListOf(), assign.position)
+                val ifelse = IfElse(expr.copy(), assignTrue, assignFalse, assign.position)
+                ifelse.linkParents(expr)
+                asmgen.translate(ifelse)
+                return true
+            }
+        }
+
+        if(!expr.inferType(program).isInteger)
+            return false
+
+        if(expr.operator!="+" && expr.operator!="-")
+            return false
+
+        val dt = expr.inferType(program).getOrElse { throw AssemblyError("invalid dt") }
+        val left = expr.left
+        val right = expr.right
+        if(dt in ByteDatatypes) {
+            when (right) {
+                is IdentifierReference -> {
+                    assignExpressionToRegister(left, RegisterOrPair.A, dt==DataType.BYTE)
+                    val symname = asmgen.asmVariableName(right)
+                    if(expr.operator=="+")
+                        asmgen.out("  clc |  adc  $symname")
+                    else
+                        asmgen.out("  sec |  sbc  $symname")
+                    assignRegisterByte(assign.target, CpuRegister.A)
+                    return true
+                }
+                is NumericLiteral -> {
+                    assignExpressionToRegister(left, RegisterOrPair.A, dt==DataType.BYTE)
+                    if(expr.operator=="+")
+                        asmgen.out("  clc |  adc  #${right.number.toHex()}")
+                    else
+                        asmgen.out("  sec |  sbc  #${right.number.toHex()}")
+                    assignRegisterByte(assign.target, CpuRegister.A)
+                    return true
+                }
+                else -> return false
+            }
+        } else if(dt in WordDatatypes) {
+            when (right) {
+                is AddressOf -> {
+                    assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
+                    val symbol = asmgen.asmVariableName(right.identifier)
+                    if(expr.operator=="+")
+                        asmgen.out("""
+                            clc
+                            adc  #<$symbol
+                            pha
+                            tya
+                            adc  #>$symbol
+                            tay
+                            pla""")
+                    else
+                        asmgen.out("""
+                            sec
+                            sbc  #<$symbol
+                            pha
+                            tya
+                            sbc  #>$symbol
+                            tay
+                            pla""")
+                    assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                    return true
+                }
+                is IdentifierReference -> {
+                    val symname = asmgen.asmVariableName(right)
+                    assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
+                    if(expr.operator=="+")
+                        asmgen.out("""
+                            clc
+                            adc  $symname
+                            pha
+                            tya
+                            adc  $symname+1
+                            tay
+                            pla""")
+                    else
+                        asmgen.out("""
+                            sec
+                            sbc  $symname
+                            pha
+                            tya
+                            sbc  $symname+1
+                            tay
+                            pla""")
+                    assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                    return true
+                }
+                is NumericLiteral -> {
+                    assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
+                    if(expr.operator=="+") {
+                        asmgen.out("""
+                            clc
+                            adc  #<${right.number.toHex()}
+                            pha
+                            tya
+                            adc  #>${right.number.toHex()}
+                            tay
+                            pla""")
+                    } else if(expr.operator=="-") {
+                        asmgen.out("""
+                            sec
+                            sbc  #<${right.number.toHex()}
+                            pha
+                            tya
+                            sbc  #>${right.number.toHex()}
+                            tay
+                            pla""")
+                    }
+                    assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                    return true
+                }
+                is TypecastExpression -> {
+                    val castedValue = right.expression
+                    if(right.type in WordDatatypes && castedValue.inferType(program).isBytes) {
+                        if(castedValue is IdentifierReference) {
+                            val castedSymname = asmgen.asmVariableName(castedValue)
+                            assignExpressionToRegister(left, RegisterOrPair.AY, dt==DataType.WORD)
+                            if(expr.operator=="+")
+                                asmgen.out("""
+                                    clc
+                                    adc  $castedSymname
+                                    bcc  +
+                                    iny
+""")
+                            else
+                                asmgen.out("""
+                                    sec
+                                    sbc  $castedSymname
+                                    bcs  +
+                                    dey
+""")
+                            assignRegisterpairWord(assign.target, RegisterOrPair.AY)
+                            return true
+                        }
+                    }
+                }
+                else -> return false
+            }
+        }
+        return false
+    }
+
+    private fun attemptAssignToByteCompareZero(expr: BinaryExpression, assign: AsmAssignment): Boolean {
+        when (expr.operator) {
+            "==" -> {
+                when(val dt = expr.left.inferType(program).getOrElse { throw AssemblyError("invalid dt") }) {
+                    in ByteDatatypes -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.A, dt==DataType.BYTE)
+                        asmgen.out("""
+                            beq  +
+                            lda  #0
+                            beq  ++
+                           lda  #1
+""")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    in WordDatatypes -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.AY, dt==DataType.WORD)
+                        asmgen.out("""
+                            sty  P8ZP_SCRATCH_B1
+                            ora  P8ZP_SCRATCH_B1
+                            beq  +
+                            lda  #0
+                            beq  ++
+                           lda  #1
+""")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    DataType.FLOAT -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+                        asmgen.out("  jsr  floats.SIGN |  and  #1 |  eor  #1")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    else->{
+                        return false
+                    }
+                }
+            }
+            "!=" -> {
+                when(val dt = expr.left.inferType(program).getOrElse { throw AssemblyError("invalid dt") }) {
+                    in ByteDatatypes -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.A, dt==DataType.BYTE)
+                        asmgen.out("  beq  + |  lda  #1")
+                        asmgen.out("+")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    in WordDatatypes -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.AY, dt==DataType.WORD)
+                        asmgen.out("  sty  P8ZP_SCRATCH_B1 |  ora  P8ZP_SCRATCH_B1")
+                        asmgen.out("  beq  + |  lda  #1")
+                        asmgen.out("+")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    DataType.FLOAT -> {
+                        assignExpressionToRegister(expr.left, RegisterOrPair.FAC1, true)
+                        asmgen.out("  jsr  floats.SIGN")
+                        assignRegisterByte(assign.target, CpuRegister.A)
+                        return true
+                    }
+                    else->{
+                        return false
+                    }
+                }
+            }
+            else -> return false
+        }
+    }
+
    private fun fallbackToStackEval(assign: AsmAssignment) {
        // TODO DON'T STACK-EVAL... perhaps by using a temp var? so that it becomes augmentable assignment expression?
        //      or don't try to solve it here in this one case and rather rewrite the whole stack based value evaluation.
@@ -336,8 +553,6 @@ internal class AssignmentAsmGen(private val program: Program,
        val variable = (containment.iterable as? IdentifierReference)?.targetVarDecl(program)
            ?: throw AssemblyError("invalid containment iterable type")

-        if(elementDt istype DataType.FLOAT)
-            throw AssemblyError("containment check of floats not supported")
        if(variable.origin!=VarDeclOrigin.USERCODE) {
            when(variable.datatype) {
                DataType.STR -> {
@@ -396,7 +611,9 @@ internal class AssignmentAsmGen(private val program: Program,
                asmgen.out("  jsr  prog8_lib.containment_bytearray")
                return
            }
-            DataType.ARRAY_F -> throw AssemblyError("containment check of floats not supported")
+            DataType.ARRAY_F -> {
+                throw AssemblyError("containment check of floats not supported")
+            }
            DataType.ARRAY_B, DataType.ARRAY_UB -> {
                val arrayVal = variable.value as ArrayLiteral
                assignExpressionToRegister(containment.element, RegisterOrPair.A, elementDt istype DataType.BYTE)
@@ -521,10 +738,10 @@ internal class AssignmentAsmGen(private val program: Program,
            return
        }

-        if(origTypeCastExpression.type == DataType.UBYTE) {
+        if(valueDt in WordDatatypes && origTypeCastExpression.type == DataType.UBYTE) {
            val parentTc = origTypeCastExpression.parent as? TypecastExpression
            if(parentTc!=null && parentTc.type==DataType.UWORD) {
-                // typecast something to ubyte and directly back to uword
+                // typecast a word value to ubyte and directly back to uword
                // generate code for lsb(value) here instead of the ubyte typecast
                return assignCastViaLsbFunc(value, target)
            }
@@ -568,7 +785,28 @@ internal class AssignmentAsmGen(private val program: Program,
        }

        if(target.kind==TargetStorageKind.REGISTER) {
-            assignExpressionToRegister(value, target.register!!, targetDt==DataType.BYTE || targetDt==DataType.WORD)
+            if(valueDt==DataType.FLOAT && target.datatype!=DataType.FLOAT) {
+                // have to typecast the float number on the fly down to an integer
+                assignExpressionToRegister(value, RegisterOrPair.FAC1, target.datatype in SignedDatatypes)
+                assignTypeCastedFloatFAC1("P8ZP_SCRATCH_W1", target.datatype)
+                assignVariableToRegister("P8ZP_SCRATCH_W1", target.register!!, target.datatype in SignedDatatypes)
+            } else {
+                if(!(valueDt isAssignableTo targetDt)) {
+                    if(valueDt in WordDatatypes && targetDt in ByteDatatypes) {
+                        // word to byte, just take the lsb
+                        return assignCastViaLsbFunc(value, target)
+                    } else if(valueDt in WordDatatypes && targetDt in WordDatatypes) {
+                        // word to word, just assign
+                        assignExpressionToRegister(value, target.register!!, targetDt==DataType.BYTE || targetDt==DataType.WORD)
+                    } else if(valueDt in ByteDatatypes && targetDt in ByteDatatypes) {
+                        // byte to byte, just assign
+                        assignExpressionToRegister(value, target.register!!, targetDt==DataType.BYTE || targetDt==DataType.WORD)
+                    }
+                    else
+                        throw AssemblyError("can't cast $valueDt to $targetDt, this should have been checked in the astchecker")
+                }
+                assignExpressionToRegister(value, target.register!!, targetDt==DataType.BYTE || targetDt==DataType.WORD)
+            }
            return
        }

@@ -635,7 +873,7 @@ internal class AssignmentAsmGen(private val program: Program,
        when(sourceDt) {
            DataType.UBYTE -> {
                when(targetDt) {
-                    DataType.UBYTE, DataType.BYTE -> {
+                    DataType.BYTE -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                    }
                    DataType.UWORD, DataType.WORD -> {
@@ -658,7 +896,7 @@ internal class AssignmentAsmGen(private val program: Program,
            }
            DataType.BYTE -> {
                when(targetDt) {
-                    DataType.UBYTE, DataType.BYTE -> {
+                    DataType.UBYTE -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                    }
                    DataType.UWORD -> {
@@ -688,7 +926,7 @@ internal class AssignmentAsmGen(private val program: Program,
                    DataType.BYTE, DataType.UBYTE -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                    }
-                    DataType.WORD, DataType.UWORD -> {
+                    DataType.WORD -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  $sourceAsmVarName+1 |  sta  $targetAsmVarName+1")
                    }
                    DataType.FLOAT -> {
@@ -709,7 +947,7 @@ internal class AssignmentAsmGen(private val program: Program,
                    DataType.BYTE, DataType.UBYTE -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName")
                    }
-                    DataType.WORD, DataType.UWORD -> {
+                    DataType.UWORD -> {
                        asmgen.out("  lda  $sourceAsmVarName |  sta  $targetAsmVarName |  lda  $sourceAsmVarName+1 |  sta  $targetAsmVarName+1")
                    }
                    DataType.FLOAT -> {
@@ -750,7 +988,7 @@ internal class AssignmentAsmGen(private val program: Program,
        when(sourceDt) {
            DataType.UBYTE -> {
                when(targetDt) {
-                    DataType.UBYTE, DataType.BYTE -> {
+                    DataType.BYTE -> {
                        asmgen.out("  st${regs.toString().lowercase()}  $targetAsmVarName")
                    }
                    DataType.UWORD, DataType.WORD -> {
@@ -784,7 +1022,7 @@ internal class AssignmentAsmGen(private val program: Program,
            }
            DataType.BYTE -> {
                when(targetDt) {
-                    DataType.UBYTE, DataType.BYTE -> {
+                    DataType.UBYTE -> {
                        asmgen.out("  st${regs.toString().lowercase()}  $targetAsmVarName")
                    }
                    DataType.UWORD -> {
@@ -831,7 +1069,7 @@ internal class AssignmentAsmGen(private val program: Program,
                    DataType.BYTE, DataType.UBYTE -> {
                        asmgen.out("  st${regs.toString().lowercase().first()}  $targetAsmVarName")
                    }
-                    DataType.WORD, DataType.UWORD -> {
+                    DataType.WORD -> {
                        when(regs) {
                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
@@ -859,7 +1097,7 @@ internal class AssignmentAsmGen(private val program: Program,
                    DataType.BYTE, DataType.UBYTE -> {
                        asmgen.out("  st${regs.toString().lowercase().first()}  $targetAsmVarName")
                    }
-                    DataType.WORD, DataType.UWORD -> {
+                    DataType.UWORD -> {
                        when(regs) {
                            RegisterOrPair.AX -> asmgen.out("  sta  $targetAsmVarName |  stx  $targetAsmVarName+1")
                            RegisterOrPair.AY -> asmgen.out("  sta  $targetAsmVarName |  sty  $targetAsmVarName+1")
@@ -1265,7 +1503,7 @@ internal class AssignmentAsmGen(private val program: Program,
            TargetStorageKind.MEMORY -> throw AssemblyError("can't assign float to mem byte")
            TargetStorageKind.REGISTER -> {
                if (target.register!! != RegisterOrPair.FAC1)
-                    throw AssemblyError("can't assign Fac1 float to another fac register")
+                    throw AssemblyError("can't assign Fac1 float to another register")
            }
            TargetStorageKind.STACK -> asmgen.out("  jsr  floats.push_fac1")
        }
@@ -1366,6 +1604,22 @@ internal class AssignmentAsmGen(private val program: Program,
                storeRegisterAInMemoryAddress(target.memory!!)
            }
            TargetStorageKind.ARRAY -> {
+                if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                    // assigning an indexed pointer var
+                    if (target.constArrayIndexValue==0u) {
+                        asmgen.out("  lda  $sourceName")
+                        asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                    } else {
+                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                        if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                            asmgen.out("  lda  $sourceName |  sta  (${target.asmVarname}),y")
+                        } else {
+                            asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
+                            asmgen.out("  lda  $sourceName |  sta  (P8ZP_SCRATCH_W2),y")
+                        }
+                    }
+                    return
+                }
                if (target.constArrayIndexValue!=null) {
                    val scaledIdx = target.constArrayIndexValue!! * program.memsizer.memorySize(target.datatype).toUInt()
                    asmgen.out(" lda  $sourceName  | sta  ${target.asmVarname}+$scaledIdx")
@@ -1898,6 +2152,22 @@ internal class AssignmentAsmGen(private val program: Program,
                    storeRegisterAInMemoryAddress(target.memory!!)
                }
                TargetStorageKind.ARRAY -> {
+                    if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                        // assigning an indexed pointer var
+                        if (target.constArrayIndexValue==0u) {
+                            asmgen.out("  lda  #0")
+                            asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                        } else {
+                            asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                            if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                                asmgen.out("  lda  #0 |  sta  (${target.asmVarname}),y")
+                            } else {
+                                asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
+                                asmgen.out("  lda  #0 |  sta  (P8ZP_SCRATCH_W2),y")
+                            }
+                        }
+                        return
+                    }
                    if (target.constArrayIndexValue!=null) {
                        val indexValue = target.constArrayIndexValue!!
                        asmgen.out("  stz  ${target.asmVarname}+$indexValue")
@@ -1916,10 +2186,7 @@ internal class AssignmentAsmGen(private val program: Program,
                    RegisterOrPair.XY -> asmgen.out("  ldx  #0 |  ldy  #0")
                    RegisterOrPair.FAC1, RegisterOrPair.FAC2 -> throw AssemblyError("expected typecasted byte to float")
                    in Cx16VirtualRegisters -> {
-                        asmgen.out(
-                            "  stz  cx16.${
-                                target.register.toString().lowercase()
-                            } |  stz  cx16.${target.register.toString().lowercase()}+1")
+                        asmgen.out("  stz  cx16.${target.register.toString().lowercase()} |  stz  cx16.${target.register.toString().lowercase()}+1")
                    }
                    else -> throw AssemblyError("weird register")
                }
@@ -1941,13 +2208,29 @@ internal class AssignmentAsmGen(private val program: Program,
                storeRegisterAInMemoryAddress(target.memory!!)
            }
            TargetStorageKind.ARRAY -> {
+                if(target.origAstTarget?.arrayindexed?.arrayvar?.targetVarDecl(program)?.datatype==DataType.UWORD) {
+                    // assigning an indexed pointer var
+                    if (target.constArrayIndexValue==0u) {
+                        asmgen.out("  lda  #${byte.toHex()}")
+                        asmgen.storeAIntoPointerVar(target.origAstTarget.arrayindexed!!.arrayvar)
+                    } else {
+                        asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
+                        if (asmgen.isZpVar(target.origAstTarget.arrayindexed!!.arrayvar)) {
+                            asmgen.out("  lda  #${byte.toHex()} |  sta  (${target.asmVarname}),y")
+                        } else {
+                            asmgen.out("  lda  ${target.asmVarname} |  sta  P8ZP_SCRATCH_W2 |  lda  ${target.asmVarname}+1 |  sta  P8ZP_SCRATCH_W2+1")
+                            asmgen.out("  lda  #${byte.toHex()} |  sta  (P8ZP_SCRATCH_W2),y")
+                        }
+                    }
+                    return
+                }
                if (target.constArrayIndexValue!=null) {
                    val indexValue = target.constArrayIndexValue!!
                    asmgen.out("  lda  #${byte.toHex()} |  sta  ${target.asmVarname}+$indexValue")
                }
                else {
                    asmgen.loadScaledArrayIndexIntoRegister(target.array!!, DataType.UBYTE, CpuRegister.Y)
-                    asmgen.out("  lda  #<${byte.toHex()} |  sta  ${target.asmVarname},y")
+                    asmgen.out("  lda  #${byte.toHex()} |  sta  ${target.asmVarname},y")
                }
            }
            TargetStorageKind.REGISTER -> when(target.register!!) {
@@ -2302,10 +2585,14 @@ internal class AssignmentAsmGen(private val program: Program,
    }

    internal fun assignExpressionToVariable(expr: Expression, asmVarName: String, dt: DataType, scope: Subroutine?) {
-        val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
-        val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, scope, variableAsmName = asmVarName)
-        val assign = AsmAssignment(src, tgt, false, program.memsizer, expr.position)
-        translateNormalAssignment(assign)
+        if(expr.inferType(program) istype DataType.FLOAT && dt!=DataType.FLOAT) {
+            throw AssemblyError("can't directly assign a FLOAT expression to an integer variable $expr")
+        } else {
+            val src = AsmAssignSource.fromAstSource(expr, program, asmgen)
+            val tgt = AsmAssignTarget(TargetStorageKind.VARIABLE, program, asmgen, dt, scope, variableAsmName = asmVarName)
+            val assign = AsmAssignment(src, tgt, false, program.memsizer, expr.position)
+            translateNormalAssignment(assign)
+        }
    }

    internal fun assignVariableToRegister(asmVarName: String, register: RegisterOrPair, signed: Boolean) {
@@ -28,7 +28,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    "+" -> {}
                    "-" -> inplaceNegate(target, type)
                    "~" -> inplaceInvert(target, type)
-                    "not" -> inplaceBooleanNot(target, type)
                    else -> throw AssemblyError("invalid prefix operator")
                }
            }
@@ -391,9 +390,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    bne  -
 +""")
            }
-            "&", "and" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
-            "|", "or" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
-            "^", "xor" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
+            "&" -> asmgen.out(" and  P8ZP_SCRATCH_B1")
+            "|" -> asmgen.out(" ora  P8ZP_SCRATCH_B1")
+            "^" -> asmgen.out(" eor  P8ZP_SCRATCH_B1")
            else -> throw AssemblyError("invalid operator for in-place modification $operator")
        }
        asmgen.storeAIntoZpPointerVar(sourceName)
@@ -428,9 +427,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                        bne  -
 +""")
            }
-            "&", "and" -> asmgen.out(" and  $otherName")
-            "|", "or" -> asmgen.out(" ora  $otherName")
-            "^", "xor" -> asmgen.out(" eor  $otherName")
+            "&" -> asmgen.out(" and  $otherName")
+            "|" -> asmgen.out(" ora  $otherName")
+            "^" -> asmgen.out(" eor  $otherName")
            else -> throw AssemblyError("invalid operator for in-place modification $operator")
        }
        asmgen.storeAIntoZpPointerVar(sourceName)
@@ -485,17 +484,17 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    asmgen.storeAIntoZpPointerVar(sourceName)
                }
            }
-            "&", "and" -> {
+            "&" -> {
                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
                asmgen.out("  and  #$value")
                asmgen.storeAIntoZpPointerVar(sourceName)
            }
-            "|", "or" -> {
+            "|"-> {
                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
                asmgen.out("  ora  #$value")
                asmgen.storeAIntoZpPointerVar(sourceName)
            }
-            "^", "xor" -> {
+            "^" -> {
                val sourceName = asmgen.loadByteFromPointerIntoA(pointervar)
                asmgen.out("  eor  #$value")
                asmgen.storeAIntoZpPointerVar(sourceName)
@@ -563,15 +562,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                }
            }
-            "&", "and" -> {
+            "&" -> {
                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                asmgen.out("  and  $name |  sta  $name")
            }
-            "|", "or" -> {
+            "|" -> {
                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                asmgen.out("  ora  $name |  sta  $name")
            }
-            "^", "xor" -> {
+            "^" -> {
                asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                asmgen.out("  eor  $name |  sta  $name")
            }
@@ -649,9 +648,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                }
            }
-            "&", "and" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name")
-            "|", "or" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name")
-            "^", "xor" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name")
+            "&" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name")
+            "|" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name")
+            "^" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name")
            "==" -> {
                asmgen.out("""
                    lda  $otherName
@@ -740,9 +739,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    }
                }
            }
-            "&", "and" -> asmgen.out(" lda  $name |  and  #$value |  sta  $name")
-            "|", "or" -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
-            "^", "xor" -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
+            "&" -> asmgen.out(" lda  $name |  and  #$value |  sta  $name")
+            "|" -> asmgen.out(" lda  $name |  ora  #$value |  sta  $name")
+            "^" -> asmgen.out(" lda  $name |  eor  #$value |  sta  $name")
            "==" -> {
                asmgen.out("""
                    lda  $name
@@ -785,15 +784,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    sbc  P8ZP_SCRATCH_B1
                    sta  $name""")
            }
-            "|", "or" -> {
+            "|" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  ora  $name  |  sta  $name")
            }
-            "&", "and" -> {
+            "&" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  and  $name  |  sta  $name")
            }
-            "^", "xor" -> {
+            "^" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  eor  $name  |  sta  $name")
            }
@@ -828,11 +827,11 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    dec  $name+1
 +""")
            }
-            "|", "or" -> {
+            "|" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  ora  $name  |  sta  $name")
            }
-            "&", "and" -> {
+            "&" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  and  $name  |  sta  $name")
                if(dt in WordDatatypes) {
@@ -842,7 +841,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                        asmgen.out("  lda  #0 |  sta  $name+1")
                }
            }
-            "^", "xor" -> {
+            "^" -> {
                asmgen.translateDirectMemReadExpressionToRegAorStack(memread, false)
                asmgen.out("  eor  $name  |  sta  $name")
            }
@@ -1059,7 +1058,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    }
                }
            }
-            "&", "and" -> {
+            "&" -> {
                when {
                    value == 0 -> {
                        if(asmgen.isTargetCpu(CpuType.CPU65c02))
@@ -1096,7 +1095,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    else -> asmgen.out("  lda  $name |  and  #<$value |  sta  $name |  lda  $name+1 |  and  #>$value |  sta  $name+1")
                }
            }
-            "|", "or" -> {
+            "|" -> {
                when {
                    value == 0 -> {}
                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  ora  #>$value |  sta  $name+1")
@@ -1104,7 +1103,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                    else -> asmgen.out("  lda  $name |  ora  #<$value |  sta  $name |  lda  $name+1 |  ora  #>$value |  sta  $name+1")
                }
            }
-            "^", "xor" -> {
+            "^" -> {
                when {
                    value == 0 -> {}
                    value and 255 == 0 -> asmgen.out("  lda  $name+1 |  eor  #>$value |  sta  $name+1")
@@ -1268,7 +1267,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
 +""")
                        }
                    }
-                    "&", "and" -> {
+                    "&" -> {
                        asmgen.out("  lda  $otherName |  and  $name |  sta  $name")
                        if(dt in WordDatatypes) {
                            if(asmgen.isTargetCpu(CpuType.CPU65c02))
@@ -1277,8 +1276,8 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                asmgen.out("  lda  #0 |  sta  $name+1")
                        }
                    }
-                    "|", "or" -> asmgen.out("  lda  $otherName |  ora  $name |  sta  $name")
-                    "^", "xor" -> asmgen.out("  lda  $otherName |  eor  $name |  sta  $name")
+                    "|" -> asmgen.out("  lda  $otherName |  ora  $name |  sta  $name")
+                    "^" -> asmgen.out("  lda  $otherName |  eor  $name |  sta  $name")
                    else -> throw AssemblyError("invalid operator for in-place modification $operator")
                }
            }
@@ -1349,9 +1348,9 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                        """)
                    }
                    "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
-                    "&", "and" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name |  lda  $name+1 |  and  $otherName+1 |  sta  $name+1")
-                    "|", "or" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name |  lda  $name+1 |  ora  $otherName+1 |  sta  $name+1")
-                    "^", "xor" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name |  lda  $name+1 |  eor  $otherName+1 |  sta  $name+1")
+                    "&" -> asmgen.out(" lda  $name |  and  $otherName |  sta  $name |  lda  $name+1 |  and  $otherName+1 |  sta  $name+1")
+                    "|" -> asmgen.out(" lda  $name |  ora  $otherName |  sta  $name |  lda  $name+1 |  ora  $otherName+1 |  sta  $name+1")
+                    "^" -> asmgen.out(" lda  $name |  eor  $otherName |  sta  $name |  lda  $name+1 |  eor  $otherName+1 |  sta  $name+1")
                    else -> throw AssemblyError("invalid operator for in-place modification $operator")
                }
            }
@@ -1521,7 +1520,7 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                            bne  -
 +""")
                    }
-                    "&", "and" -> {
+                    "&" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                        asmgen.out("  and  $name |  sta  $name")
                        if(dt in WordDatatypes) {
@@ -1531,11 +1530,11 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                                asmgen.out("  lda  #0 |  sta  $name+1")
                        }
                    }
-                    "|", "or" -> {
+                    "|" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                        asmgen.out("  ora  $name |  sta  $name")
                    }
-                    "^", "xor" -> {
+                    "^" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.A)
                        asmgen.out("  eor  $name |  sta  $name")
                    }
@@ -1567,15 +1566,15 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
                        remainderVarByWordInAY()
                    }
                    "<<", ">>" -> throw AssemblyError("shift by a word value not supported, max is a byte")
-                    "&", "and" -> {
+                    "&" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
                        asmgen.out("  and  $name |  sta  $name |  tya |  and  $name+1 |  sta  $name+1")
                    }
-                    "|", "or" -> {
+                    "|" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
                        asmgen.out("  ora  $name |  sta  $name |  tya |  ora  $name+1 |  sta  $name+1")
                    }
-                    "^", "xor" -> {
+                    "^" -> {
                        asmgen.assignExpressionToRegister(value, RegisterOrPair.AY)
                        asmgen.out("  eor  $name |  sta  $name |  tya |  eor  $name+1 |  sta  $name+1")
                    }
@@ -1800,136 +1799,6 @@ internal class AugmentableAssignmentAsmGen(private val program: Program,
        }
    }

-    internal fun inplaceBooleanNot(target: AsmAssignTarget, dt: DataType) {
-        when (dt) {
-            DataType.UBYTE -> {
-                when (target.kind) {
-                    TargetStorageKind.VARIABLE -> {
-                        asmgen.out("""
-                            lda  ${target.asmVarname}
-                            beq  +
-                            lda  #1
-+                           eor  #1
-                            sta  ${target.asmVarname}""")
-                    }
-                    TargetStorageKind.MEMORY -> {
-                        val mem = target.memory!!
-                        when (mem.addressExpression) {
-                            is NumericLiteral -> {
-                                val addr = (mem.addressExpression as NumericLiteral).number.toHex()
-                                asmgen.out("""
-                                    lda  $addr
-                                    beq  +
-                                    lda  #1
-+                                   eor  #1
-                                    sta  $addr""")
-                            }
-                            is IdentifierReference -> {
-                                val sourceName = asmgen.loadByteFromPointerIntoA(mem.addressExpression as IdentifierReference)
-                                asmgen.out("""
-                                    beq  +
-                                    lda  #1
-+                                   eor  #1""")
-                                asmgen.storeAIntoZpPointerVar(sourceName)
-                            }
-                            else -> {
-                                asmgen.assignExpressionToVariable(mem.addressExpression, "P8ZP_SCRATCH_W2", DataType.UWORD, target.scope)
-                                asmgen.loadAFromZpPointerVar("P8ZP_SCRATCH_W2")
-                                asmgen.out("""
-                                    beq  +
-                                    lda  #1
-+                                   eor  #1""")
-                                asmgen.storeAIntoZpPointerVar("P8ZP_SCRATCH_W2")
-                            }
-                        }
-                    }
-                    TargetStorageKind.REGISTER -> {
-                        when(target.register!!) {
-                            RegisterOrPair.A -> asmgen.out("""
-                                cmp  #0
-                                beq  +
-                                lda  #1
-+                               eor  #1""")
-                            RegisterOrPair.X -> asmgen.out("""
-                                txa
-                                beq  +
-                                lda  #1
-+                               eor  #1
-                                tax""")
-                            RegisterOrPair.Y -> asmgen.out("""
-                                tya
-                                beq  +
-                                lda  #1
-+                               eor  #1
-                                tay""")
-                            else -> throw AssemblyError("invalid reg dt for byte not")
-                        }
-                    }
-                    TargetStorageKind.STACK -> TODO("no asm gen for byte stack not")
-                    else -> throw AssemblyError("no asm gen for in-place not of ubyte ${target.kind}")
-                }
-            }
-            DataType.UWORD -> {
-                when (target.kind) {
-                    TargetStorageKind.VARIABLE -> {
-                        asmgen.out("""
-                            lda  ${target.asmVarname}
-                            ora  ${target.asmVarname}+1
-                            beq  +
-                            lda  #1
-+                           eor  #1
-                            sta  ${target.asmVarname}
-                            lsr  a
-                            sta  ${target.asmVarname}+1""")
-                    }
-                    TargetStorageKind.REGISTER -> {
-                        when(target.register!!) {
-                            RegisterOrPair.AX -> {
-                                asmgen.out("""
-                                    stx  P8ZP_SCRATCH_REG
-                                    ora  P8ZP_SCRATCH_REG
-                                    beq  +
-                                    lda  #0
-                                    tax
-                                    beq  ++
-        +                           lda  #1
-        +""")
-                            }
-                            RegisterOrPair.AY -> {
-                                asmgen.out("""
-                                    sty  P8ZP_SCRATCH_REG
-                                    ora  P8ZP_SCRATCH_REG
-                                    beq  +
-                                    lda  #0
-                                    tay
-                                    beq  ++
-        +                           lda  #1
-        +""")
-                            }
-                            RegisterOrPair.XY -> {
-                                asmgen.out("""
-                                    stx  P8ZP_SCRATCH_REG
-                                    tya
-                                    ora  P8ZP_SCRATCH_REG
-                                    beq  +
-                                    ldy  #0
-                                    ldx  #0
-                                    beq  ++
-        +                           ldx  #1
-        +""")
-                            }
-                            in Cx16VirtualRegisters -> throw AssemblyError("cx16 virtual regs should be variables, not real registers")
-                            else -> throw AssemblyError("invalid reg dt for word not")
-                        }
-                    }
-                    TargetStorageKind.STACK -> TODO("no asm gen for word stack not")
-                    else -> throw AssemblyError("no asm gen for in-place not of uword for ${target.kind}")
-                }
-            }
-            else -> throw AssemblyError("boolean-not of invalid type")
-        }
-    }
-
    internal fun inplaceInvert(target: AsmAssignTarget, dt: DataType) {
        when (dt) {
            DataType.UBYTE -> {
@@ -28,7 +28,7 @@ dependencies {
    implementation project(':codeCore')
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"

 }

@@ -135,6 +135,8 @@ class AstToXmlConverter(internal val program: PtProgram,
        xml.attr("nosysinit", options.noSysInit.toString())
        xml.attr("dontreinitglobals", options.dontReinitGlobals.toString())
        xml.attr("optimize", options.optimize.toString())
+        if(options.evalStackBaseAddress!=null)
+            xml.attr("evalstackbase", options.evalStackBaseAddress!!.toString())
        if(options.zpReserved.isNotEmpty()) {
            xml.startChildren()
            options.zpReserved.forEach {
@@ -144,6 +146,15 @@ class AstToXmlConverter(internal val program: PtProgram,
                xml.endElt()
            }
        }
+        if(options.symbolDefs.isNotEmpty()) {
+            xml.startChildren()
+            options.symbolDefs.forEach { name, value ->
+                xml.elt("symboldef")
+                xml.attr("name", name)
+                xml.attr("value", value)
+                xml.endElt()
+            }
+        }
        xml.endElt()
    }

@@ -172,7 +183,6 @@ class AstToXmlConverter(internal val program: PtProgram,
            is PtMemoryByte -> write(it)
            is PtMemMapped -> write(it)
            is PtNumber -> write(it)
-            is PtPipe -> write(it)
            is PtPostIncrDecr -> write(it)
            is PtPrefix -> write(it)
            is PtRange -> write(it)
@@ -204,14 +214,6 @@ class AstToXmlConverter(internal val program: PtProgram,
        xml.endElt()
    }

-    private fun write(pipe: PtPipe) {
-        xml.elt("pipe")
-        xml.attr("type", pipe.type.name)
-        xml.startChildren()
-        pipe.children.forEach { writeNode(it) }
-        xml.endElt()
-    }
-
    private fun write(array: PtArray) {
        xml.elt("array")
        xml.attr("type", array.type.name)
@@ -445,7 +447,6 @@ class AstToXmlConverter(internal val program: PtProgram,

    private fun write(assign: PtAssignment) {
        xml.elt("assign")
-        xml.attr("aug", assign.augmentable.toString())
        xml.pos(assign.position)
        xml.startChildren()
        write(assign.target)
@@ -613,7 +614,7 @@ class AstToXmlConverter(internal val program: PtProgram,
        }
        if(asmSub.clobbers.isNotEmpty()) {
            xml.elt("clobbers")
-            xml.attr("registers", asmSub.clobbers.map {it.name}.joinToString(","))
+            xml.attr("registers", asmSub.clobbers.joinToString(",") { it.name })
            xml.endElt()
        }
        if(asmSub.retvalRegisters.isNotEmpty()) {
@@ -3,6 +3,7 @@ plugins {
    id 'java'
    id 'application'
    id "org.jetbrains.kotlin.jvm"
+    id "io.kotest" version "0.3.9"
 }

 java {
@@ -24,13 +25,14 @@ compileTestKotlin {
 }

 dependencies {
-    implementation project(':virtualmachine')
    implementation project(':codeAst')
    implementation project(':codeCore')
+    implementation project(':virtualmachine')
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    // implementation "org.jetbrains.kotlin:kotlin-reflect"
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"

+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
 }

 sourceSets {
@@ -42,6 +44,22 @@ sourceSets {
            srcDirs = ["${project.projectDir}/res"]
        }
    }
+    test {
+        java {
+            srcDir "${project.projectDir}/test"
+        }
+    }
 }

-// note: there are no unit tests in this module!
+test {
+    // Enable JUnit 5 (Gradle 4.6+).
+    useJUnitPlatform()
+
+    // Always run tests, even when nothing changed.
+    dependsOn 'cleanTest'
+
+    // Show test results.
+    testLogging {
+        events "skipped", "failed"
+    }
+}
@@ -4,11 +4,14 @@
    <exclude-output />
    <content url="file://$MODULE_DIR$">
      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+      <sourceFolder url="file://$MODULE_DIR$/test" isTestSource="true" />
    </content>
    <orderEntry type="inheritedJdk" />
    <orderEntry type="sourceFolder" forTests="false" />
    <orderEntry type="library" name="KotlinJavaRuntime" level="project" />
    <orderEntry type="library" name="michael.bull.kotlin.result.jvm" level="project" />
+    <orderEntry type="library" name="io.kotest.assertions.core.jvm" level="project" />
+    <orderEntry type="library" name="io.kotest.runner.junit5.jvm" level="project" />
    <orderEntry type="module" module-name="codeAst" />
    <orderEntry type="module" module-name="codeCore" />
    <orderEntry type="module" module-name="virtualmachine" />
@@ -1,17 +1,19 @@
 package prog8.codegen.virtual

+import prog8.code.core.AssemblyError
 import prog8.code.core.CompilationOptions
 import prog8.code.core.IAssemblyProgram
 import prog8.vm.Instruction
 import prog8.vm.Opcode
+import prog8.vm.OpcodesWithAddress
 import prog8.vm.VmDataType
 import java.io.BufferedWriter
+import java.nio.file.Path
 import kotlin.io.path.bufferedWriter
 import kotlin.io.path.div


-internal class AssemblyProgram(override val name: String,
-                               private val allocations: VariableAllocator
+class AssemblyProgram(override val name: String, private val allocations: VariableAllocator
 ) : IAssemblyProgram {

    private val globalInits = mutableListOf<VmCodeLine>()
@@ -27,8 +29,10 @@ internal class AssemblyProgram(override val name: String,
            }
            out.write("------PROGRAM------\n")

-            out.write("; global var inits\n")
-            globalInits.forEach { out.writeLine(it) }
+            if(!options.dontReinitGlobals) {
+                out.write("; global var inits\n")
+                globalInits.forEach { out.writeLine(it) }
+            }

            out.write("; actual program code\n")
            blocks.asSequence().flatMap { it.lines }.forEach { line->out.writeLine(line) }
@@ -43,30 +47,74 @@ internal class AssemblyProgram(override val name: String,
                write(line.ins.toString() + "\n")
            }
            is VmCodeLabel -> write("_" + line.name.joinToString(".") + ":\n")
+            is VmCodeInlineAsm -> {
+                val asm = line.assembly.replace("""\{[a-zA-Z\d_\.]+\}""".toRegex()) { matchResult ->
+                    val name = matchResult.value.substring(1, matchResult.value.length-1).split('.')
+                    allocations.get(name).toString() }
+                write(asm+"\n")
+            }
+            is VmCodeInlineBinary -> {
+                write("incbin \"${line.file}\"")
+                if(line.offset!=null)
+                    write(",${line.offset}")
+                if(line.length!=null)
+                    write(",${line.length}")
+                write("\n")
+            }
+            else -> throw AssemblyError("invalid vm code line")
        }
    }

    fun addGlobalInits(chunk: VmCodeChunk) = globalInits.addAll(chunk.lines)
    fun addBlock(block: VmCodeChunk) = blocks.add(block)
+    fun getBlocks(): List<VmCodeChunk> = blocks
 }

-internal sealed class VmCodeLine
+sealed class VmCodeLine

-internal class VmCodeInstruction(
+class VmCodeInstruction(
    opcode: Opcode,
    type: VmDataType?=null,
    reg1: Int?=null,        // 0-$ffff
    reg2: Int?=null,        // 0-$ffff
-    reg3: Int?=null,        // 0-$ffff
+    fpReg1: Int?=null,      // 0-$ffff
+    fpReg2: Int?=null,      // 0-$ffff
    value: Int?=null,       // 0-$ffff
-    symbol: List<String>?=null    // alternative to value
-    ): VmCodeLine() {
-        val ins = Instruction(opcode, type, reg1, reg2, reg3, value, symbol)
+    fpValue: Float?=null,
+    labelSymbol: List<String>?=null    // alternative to value for branch/call/jump labels
+): VmCodeLine() {
+    val ins = Instruction(opcode, type, reg1, reg2, fpReg1, fpReg2, value, fpValue, labelSymbol)
+
+    init {
+        if(reg1!=null && (reg1<0 || reg1>65536))
+            throw IllegalArgumentException("reg1 out of bounds")
+        if(reg2!=null && (reg2<0 || reg2>65536))
+            throw IllegalArgumentException("reg2 out of bounds")
+        if(fpReg1!=null && (fpReg1<0 || fpReg1>65536))
+            throw IllegalArgumentException("fpReg1 out of bounds")
+        if(fpReg2!=null && (fpReg2<0 || fpReg2>65536))
+            throw IllegalArgumentException("fpReg2 out of bounds")
+
+        if(value!=null && opcode !in OpcodesWithAddress) {
+            when (type) {
+                VmDataType.BYTE -> {
+                    if (value < -128 || value > 255)
+                        throw IllegalArgumentException("value out of range for byte: $value")
+                }
+                VmDataType.WORD -> {
+                    if (value < -32768 || value > 65535)
+                        throw IllegalArgumentException("value out of range for word: $value")
+                }
+                VmDataType.FLOAT, null -> {}
+            }
+        }
    }
-internal class VmCodeLabel(val name: List<String>): VmCodeLine()
+}
+
+class VmCodeLabel(val name: List<String>): VmCodeLine()
 internal class VmCodeComment(val comment: String): VmCodeLine()

-internal class VmCodeChunk(initial: VmCodeLine? = null) {
+class VmCodeChunk(initial: VmCodeLine? = null) {
    val lines = mutableListOf<VmCodeLine>()

    init {
@@ -81,4 +129,10 @@ internal class VmCodeChunk(initial: VmCodeLine? = null) {
    operator fun plusAssign(chunk: VmCodeChunk) {
        lines.addAll(chunk.lines)
    }
-}
+}
+
+internal class VmCodeInlineAsm(asm: String): VmCodeLine() {
+    val assembly: String = asm.trimIndent()
+}
+
+internal class VmCodeInlineBinary(val file: Path, val offset: UInt?, val length: UInt?): VmCodeLine()
@@ -0,0 +1,242 @@
+package prog8.codegen.virtual
+
+import prog8.code.ast.*
+import prog8.code.core.AssemblyError
+import prog8.code.core.DataType
+import prog8.code.core.SignedDatatypes
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+
+internal class AssignmentGen(private val codeGen: CodeGen, private val expressionEval: ExpressionGen) {
+
+    internal fun translate(assignment: PtAssignment): VmCodeChunk {
+        if(assignment.target.children.single() is PtMachineRegister)
+            throw AssemblyError("assigning to a register should be done by just evaluating the expression into resultregister")
+
+        return if (assignment.isInplaceAssign)
+            translateInplaceAssign(assignment)
+        else
+            translateRegularAssign(assignment)
+    }
+
+    private fun translateInplaceAssign(assignment: PtAssignment): VmCodeChunk {
+        val ident = assignment.target.identifier
+        val memory = assignment.target.memory
+        val array = assignment.target.array
+
+        return if(ident!=null) {
+            val address = codeGen.allocations.get(ident.targetName)
+            assignSelfInMemory(address, assignment.value, assignment)
+        } else if(memory != null) {
+            if(memory.address is PtNumber)
+                assignSelfInMemory((memory.address as PtNumber).number.toInt(), assignment.value, assignment)
+            else
+                fallbackAssign(assignment)
+        } else if(array!=null) {
+            // TODO in-place array element assignment?
+            fallbackAssign(assignment)
+        } else {
+            fallbackAssign(assignment)
+        }
+    }
+
+    private fun assignSelfInMemory(
+        address: Int,
+        value: PtExpression,
+        origAssign: PtAssignment
+    ): VmCodeChunk {
+        val vmDt = codeGen.vmType(value.type)
+        val code = VmCodeChunk()
+        when(value) {
+            is PtIdentifier -> return code // do nothing, x=x null assignment.
+            is PtMachineRegister -> return code // do nothing, reg=reg null assignment
+            is PtPrefix -> return inplacePrefix(value.operator, vmDt, address)
+            is PtBinaryExpression -> return inplaceBinexpr(value.operator, value.right, vmDt, value.type in SignedDatatypes, address, origAssign)
+            is PtMemoryByte -> {
+                return if (!codeGen.options.compTarget.machine.isIOAddress(address.toUInt()))
+                    code // do nothing, mem=mem null assignment.
+                else {
+                    // read and write a (i/o) memory location to itself.
+                    val tempReg = codeGen.vmRegisters.nextFree()
+                    code += VmCodeInstruction(Opcode.LOADM, vmDt, reg1 = tempReg, value = address)
+                    code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1 = tempReg, value = address)
+                    code
+                }
+            }
+            else -> return fallbackAssign(origAssign)
+        }
+
+    }
+
+    private fun fallbackAssign(origAssign: PtAssignment): VmCodeChunk {
+        if (codeGen.options.slowCodegenWarnings)
+            codeGen.errors.warn("indirect code for in-place assignment", origAssign.position)
+        return translateRegularAssign(origAssign)
+    }
+
+    private fun inplaceBinexpr(
+        operator: String,
+        operand: PtExpression,
+        vmDt: VmDataType,
+        signed: Boolean,
+        address: Int,
+        origAssign: PtAssignment
+    ): VmCodeChunk {
+        when(operator) {
+            "+" -> return expressionEval.operatorPlusInplace(address, vmDt, operand)
+            "-" -> return expressionEval.operatorMinusInplace(address, vmDt, operand)
+            "*" -> return expressionEval.operatorMultiplyInplace(address, vmDt, operand)
+            "/" -> return expressionEval.operatorDivideInplace(address, vmDt, signed, operand)
+            "|" -> return expressionEval.operatorOrInplace(address, vmDt, operand)
+            "&" -> return expressionEval.operatorAndInplace(address, vmDt, operand)
+            "^" -> return expressionEval.operatorXorInplace(address, vmDt, operand)
+            "<<" -> return expressionEval.operatorShiftLeftInplace(address, vmDt, operand)
+            ">>" -> return expressionEval.operatorShiftRightInplace(address, vmDt, signed, operand)
+            else -> {}
+        }
+        return fallbackAssign(origAssign)
+    }
+
+    private fun inplacePrefix(operator: String, vmDt: VmDataType, address: Int): VmCodeChunk {
+        val code= VmCodeChunk()
+        when(operator) {
+            "+" -> { }
+            "-" -> {
+                code += VmCodeInstruction(Opcode.NEGM, vmDt, value = address)
+            }
+            "~" -> {
+                val regMask = codeGen.vmRegisters.nextFree()
+                val mask = if(vmDt==VmDataType.BYTE) 0x00ff else 0xffff
+                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=regMask, value = mask)
+                code += VmCodeInstruction(Opcode.XORM, vmDt, reg1=regMask, value = address)
+            }
+            else -> throw AssemblyError("weird prefix operator")
+        }
+        return code
+    }
+
+    private fun translateRegularAssign(assignment: PtAssignment): VmCodeChunk {
+        // note: assigning array and string values is done via an explicit memcopy/stringcopy function call.
+        val ident = assignment.target.identifier
+        val memory = assignment.target.memory
+        val array = assignment.target.array
+        val vmDt = codeGen.vmType(assignment.value.type)
+
+        val code = VmCodeChunk()
+        var resultRegister = -1
+        var resultFpRegister = -1
+        val zero = codeGen.isZero(assignment.value)
+        if(!zero) {
+            // calculate the assignment value
+            if (vmDt == VmDataType.FLOAT) {
+                resultFpRegister = codeGen.vmRegisters.nextFreeFloat()
+                code += expressionEval.translateExpression(assignment.value, -1, resultFpRegister)
+            } else {
+                resultRegister = if (assignment.value is PtMachineRegister) {
+                    (assignment.value as PtMachineRegister).register
+                } else {
+                    val reg = codeGen.vmRegisters.nextFree()
+                    code += expressionEval.translateExpression(assignment.value, reg, -1)
+                    reg
+                }
+            }
+        }
+        if(ident!=null) {
+            val address = codeGen.allocations.get(ident.targetName)
+            code += if(zero) {
+                VmCodeInstruction(Opcode.STOREZM, vmDt, value = address)
+            } else {
+                if (vmDt == VmDataType.FLOAT)
+                    VmCodeInstruction(Opcode.STOREM, vmDt, fpReg1 = resultFpRegister, value = address)
+                else
+                    VmCodeInstruction(Opcode.STOREM, vmDt, reg1 = resultRegister, value = address)
+            }
+        }
+        else if(array!=null) {
+            val variable = array.variable.targetName
+            var variableAddr = codeGen.allocations.get(variable)
+            val itemsize = codeGen.program.memsizer.memorySize(array.type)
+
+            if(array.variable.type==DataType.UWORD) {
+                // indexing a pointer var instead of a real array or string
+                if(itemsize!=1)
+                    throw AssemblyError("non-array var indexing requires bytes dt")
+                if(array.index.type!=DataType.UBYTE)
+                    throw AssemblyError("non-array var indexing requires bytes index")
+                val idxReg = codeGen.vmRegisters.nextFree()
+                code += expressionEval.translateExpression(array.index, idxReg, -1)
+                code += VmCodeInstruction(Opcode.STOREIX, vmDt, reg1=resultRegister, reg2=idxReg, value = variableAddr)
+                return code
+            }
+
+            val fixedIndex = constIntValue(array.index)
+            if(zero) {
+                if(fixedIndex!=null) {
+                    variableAddr += fixedIndex*itemsize
+                    code += VmCodeInstruction(Opcode.STOREZM, vmDt, value=variableAddr)
+                } else {
+                    val indexReg = codeGen.vmRegisters.nextFree()
+                    code += loadIndexReg(array, itemsize, indexReg)
+                    code += VmCodeInstruction(Opcode.STOREZX, vmDt, reg1=indexReg, value=variableAddr)
+                }
+            } else {
+                if(vmDt== VmDataType.FLOAT) {
+                    if(fixedIndex!=null) {
+                        variableAddr += fixedIndex*itemsize
+                        code += VmCodeInstruction(Opcode.STOREM, vmDt, fpReg1 = resultFpRegister, value=variableAddr)
+                    } else {
+                        val indexReg = codeGen.vmRegisters.nextFree()
+                        code += loadIndexReg(array, itemsize, indexReg)
+                        code += VmCodeInstruction(Opcode.STOREX, vmDt, reg1 = resultRegister, reg2=indexReg, value=variableAddr)
+                    }
+                } else {
+                    if(fixedIndex!=null) {
+                        variableAddr += fixedIndex*itemsize
+                        code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1 = resultRegister, value=variableAddr)
+                    } else {
+                        val indexReg = codeGen.vmRegisters.nextFree()
+                        code += loadIndexReg(array, itemsize, indexReg)
+                        code += VmCodeInstruction(Opcode.STOREX, vmDt, reg1 = resultRegister, reg2=indexReg, value=variableAddr)
+                    }
+                }
+            }
+        }
+        else if(memory!=null) {
+            require(vmDt== VmDataType.BYTE)
+            if(zero) {
+                if(memory.address is PtNumber) {
+                    code += VmCodeInstruction(Opcode.STOREZM, vmDt, value=(memory.address as PtNumber).number.toInt())
+                } else {
+                    val addressReg = codeGen.vmRegisters.nextFree()
+                    code += expressionEval.translateExpression(memory.address, addressReg, -1)
+                    code += VmCodeInstruction(Opcode.STOREZI, vmDt, reg1=addressReg)
+                }
+            } else {
+                if(memory.address is PtNumber) {
+                    code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=(memory.address as PtNumber).number.toInt())
+                } else {
+                    val addressReg = codeGen.vmRegisters.nextFree()
+                    code += expressionEval.translateExpression(memory.address, addressReg, -1)
+                    code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1=resultRegister, reg2=addressReg)
+                }
+            }
+        }
+        else
+            throw AssemblyError("weird assigntarget")
+        return code
+    }
+
+    private fun loadIndexReg(array: PtArrayIndexer, itemsize: Int, indexReg: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(itemsize==1) {
+            code += expressionEval.translateExpression(array.index, indexReg, -1)
+        }
+        else {
+            val mult = PtBinaryExpression("*", DataType.UBYTE, array.position)
+            mult.children += array.index
+            mult.children += PtNumber(DataType.UBYTE, itemsize.toDouble(), array.position)
+            code += expressionEval.translateExpression(mult, indexReg, -1)
+        }
+        return code
+    }
+}
@@ -1,8 +1,9 @@
 package prog8.codegen.virtual

-import prog8.code.ast.PtBuiltinFunctionCall
-import prog8.code.ast.PtNumber
-import prog8.code.ast.PtString
+import prog8.code.StStaticVariable
+import prog8.code.ast.*
+import prog8.code.core.AssemblyError
+import prog8.code.core.DataType
 import prog8.vm.Opcode
 import prog8.vm.Syscall
 import prog8.vm.VmDataType
@@ -10,117 +11,366 @@ import prog8.vm.VmDataType
 internal class BuiltinFuncGen(private val codeGen: CodeGen, private val exprGen: ExpressionGen) {

    fun translate(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        return when(call.name) {
+            "any" -> funcAny(call, resultRegister)
+            "all" -> funcAll(call, resultRegister)
+            "abs" -> funcAbs(call, resultRegister)
+            "cmp" -> funcCmp(call)
+            "sgn" -> funcSgn(call, resultRegister)
+            "sqrt16" -> funcSqrt16(call, resultRegister)
+            "pop" -> funcPop(call)
+            "popw" -> funcPopw(call)
+            "push" -> funcPush(call)
+            "pushw" -> funcPushw(call)
+            "rsave",
+            "rsavex",
+            "rrestore",
+            "rrestorex" -> VmCodeChunk() // vm doesn't have registers to save/restore
+            "rnd" -> funcRnd(resultRegister)
+            "rndw" -> funcRndw(resultRegister)
+            "callfar" -> throw AssemblyError("callfar() is for cx16 target only")
+            "callrom" -> throw AssemblyError("callrom() is for cx16 target only")
+            "msb" -> funcMsb(call, resultRegister)
+            "lsb" -> funcLsb(call, resultRegister)
+            "memory" -> funcMemory(call, resultRegister)
+            "peek" -> funcPeek(call, resultRegister)
+            "peekw" -> funcPeekW(call, resultRegister)
+            "poke" -> funcPoke(call)
+            "pokew" -> funcPokeW(call)
+            "pokemon" -> VmCodeChunk()
+            "mkword" -> funcMkword(call, resultRegister)
+            "sort" -> funcSort(call)
+            "reverse" -> funcReverse(call)
+            "rol" -> funcRolRor(Opcode.ROXL, call, resultRegister)
+            "ror" -> funcRolRor(Opcode.ROXR, call, resultRegister)
+            "rol2" -> funcRolRor(Opcode.ROL, call, resultRegister)
+            "ror2" -> funcRolRor(Opcode.ROR, call, resultRegister)
+            else -> TODO("builtinfunc ${call.name}")
+        }
+    }
+
+    private fun funcCmp(call: PtBuiltinFunctionCall): VmCodeChunk {
        val code = VmCodeChunk()
-        when(call.name) {
-            "syscall" -> {
-                val vExpr = call.args.single() as PtNumber
-                code += VmCodeInstruction(Opcode.SYSCALL, value=vExpr.number.toInt())
+        val leftRegister = codeGen.vmRegisters.nextFree()
+        val rightRegister = codeGen.vmRegisters.nextFree()
+        code += exprGen.translateExpression(call.args[0], leftRegister, -1)
+        code += exprGen.translateExpression(call.args[1], rightRegister, -1)
+        code += VmCodeInstruction(Opcode.CMP, codeGen.vmType(call.args[0].type), reg1=leftRegister, reg2=rightRegister)
+        return code
+    }
+
+    private fun funcAny(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val arrayName = call.args[0] as PtIdentifier
+        val array = codeGen.symbolTable.flat.getValue(arrayName.targetName) as StStaticVariable
+        val code = VmCodeChunk()
+        val syscall =
+            when (array.dt) {
+                DataType.ARRAY_UB,
+                DataType.ARRAY_B -> Syscall.ANY_BYTE
+                DataType.ARRAY_UW,
+                DataType.ARRAY_W -> Syscall.ANY_WORD
+                DataType.ARRAY_F -> Syscall.ANY_FLOAT
+                else -> throw IllegalArgumentException("weird type")
            }
-            "syscall1" -> {
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
-                val callNr = (call.args[0] as PtNumber).number.toInt()
-                code += exprGen.translateExpression(call.args[1], 0)
-                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
+        code += exprGen.translateExpression(call.args[0], 0, -1)
+        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1 = 1, value = array.length)
+        code += VmCodeInstruction(Opcode.SYSCALL, value = syscall.ordinal)
+        if (resultRegister != 0)
+            code += VmCodeInstruction(Opcode.LOADR, VmDataType.BYTE, reg1 = resultRegister, reg2 = 0)
+        return code
+    }
+
+    private fun funcAll(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val arrayName = call.args[0] as PtIdentifier
+        val array = codeGen.symbolTable.flat.getValue(arrayName.targetName) as StStaticVariable
+        val syscall =
+            when(array.dt) {
+                DataType.ARRAY_UB,
+                DataType.ARRAY_B -> Syscall.ALL_BYTE
+                DataType.ARRAY_UW,
+                DataType.ARRAY_W -> Syscall.ALL_WORD
+                DataType.ARRAY_F -> Syscall.ALL_FLOAT
+                else -> throw IllegalArgumentException("weird type")
            }
-            "syscall2" -> {
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 1)
-                while(codeGen.vmRegisters.peekNext()<2) {
-                    codeGen.vmRegisters.nextFree()
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args[0], 0, -1)
+        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=1, value=array.length)
+        code += VmCodeInstruction(Opcode.SYSCALL, value=syscall.ordinal)
+        if(resultRegister!=0)
+            code += VmCodeInstruction(Opcode.LOADR, VmDataType.BYTE, reg1=resultRegister, reg2=0)
+        return code
+    }
+
+    private fun funcAbs(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val sourceDt = call.args.single().type
+        if(sourceDt!=DataType.UWORD) {
+            code += exprGen.translateExpression(call.args[0], resultRegister, -1)
+            when (sourceDt) {
+                DataType.UBYTE -> {
+                    code += VmCodeInstruction(Opcode.EXT, VmDataType.BYTE, reg1=resultRegister)
                }
-                val callNr = (call.args[0] as PtNumber).number.toInt()
-                code += exprGen.translateExpression(call.args[1], 0)
-                code += exprGen.translateExpression(call.args[2], 1)
-                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 1)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
-            }
-            "syscall3" -> {
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 0)
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 1)
-                code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1 = 2)
-                while(codeGen.vmRegisters.peekNext()<3) {
-                    codeGen.vmRegisters.nextFree()
+                DataType.BYTE -> {
+                    val notNegativeLabel = codeGen.createLabelName()
+                    val compareReg = codeGen.vmRegisters.nextFree()
+                    code += VmCodeInstruction(Opcode.LOADR, VmDataType.BYTE, reg1=compareReg, reg2=resultRegister)
+                    code += VmCodeInstruction(Opcode.AND, VmDataType.BYTE, reg1=compareReg, value=0x80)
+                    code += VmCodeInstruction(Opcode.BZ, VmDataType.BYTE, reg1=compareReg, labelSymbol = notNegativeLabel)
+                    code += VmCodeInstruction(Opcode.NEG, VmDataType.BYTE, reg1=resultRegister)
+                    code += VmCodeInstruction(Opcode.EXT, VmDataType.BYTE, reg1=resultRegister)
+                    code += VmCodeLabel(notNegativeLabel)
                }
-                val callNr = (call.args[0] as PtNumber).number.toInt()
-                code += exprGen.translateExpression(call.args[1], 0)
-                code += exprGen.translateExpression(call.args[2], 1)
-                code += exprGen.translateExpression(call.args[3], 2)
-                code += VmCodeInstruction(Opcode.SYSCALL, value=callNr)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 2)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 1)
-                code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1 = 0)
-            }
-            "msb" -> {
-                code += exprGen.translateExpression(call.args.single(), resultRegister)
-                code += VmCodeInstruction(Opcode.SWAP, VmDataType.BYTE, reg1 = resultRegister)
-                // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
-            }
-            "lsb" -> {
-                code += exprGen.translateExpression(call.args.single(), resultRegister)
-                // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
-            }
-            "memory" -> {
-                val name = (call.args[0] as PtString).value
-                val size = (call.args[1] as PtNumber).number.toUInt()
-                val align = (call.args[2] as PtNumber).number.toUInt()
-                val existing = codeGen.allocations.getMemorySlab(name)
-                val address = if(existing==null)
-                    codeGen.allocations.allocateMemorySlab(name, size, align)
-                else if(existing.second!=size || existing.third!=align) {
-                    codeGen.errors.err("memory slab '$name' already exists with a different size or alignment", call.position)
-                    return VmCodeChunk()
+                DataType.WORD -> {
+                    val notNegativeLabel = codeGen.createLabelName()
+                    val compareReg = codeGen.vmRegisters.nextFree()
+                    code += VmCodeInstruction(Opcode.LOADR, VmDataType.WORD, reg1=compareReg, reg2=resultRegister)
+                    code += VmCodeInstruction(Opcode.AND, VmDataType.WORD, reg1=compareReg, value=0x8000)
+                    code += VmCodeInstruction(Opcode.BZ, VmDataType.WORD, reg1=compareReg, labelSymbol = notNegativeLabel)
+                    code += VmCodeInstruction(Opcode.NEG, VmDataType.WORD, reg1=resultRegister)
+                    code += VmCodeLabel(notNegativeLabel)
                }
-                else
-                    existing.first
-                code += VmCodeInstruction(Opcode.LOAD, VmDataType.WORD, reg1=resultRegister, value=address.toInt())
-            }
-            "rnd" -> {
-                code += VmCodeInstruction(Opcode.SYSCALL, value= Syscall.RND.ordinal)
-                if(resultRegister!=0)
-                    code += VmCodeInstruction(Opcode.LOADR, VmDataType.BYTE, reg1=resultRegister, reg2=0)
-            }
-            "peek" -> {
-                val addressReg = codeGen.vmRegisters.nextFree()
-                code += exprGen.translateExpression(call.args.single(), addressReg)
-                code += VmCodeInstruction(Opcode.LOADI, VmDataType.BYTE, reg1 = resultRegister, reg2=addressReg)
-            }
-            "peekw" -> {
-                val addressReg = codeGen.vmRegisters.nextFree()
-                code += exprGen.translateExpression(call.args.single(), addressReg)
-                code += VmCodeInstruction(Opcode.LOADI, VmDataType.WORD, reg1 = resultRegister, reg2=addressReg)
-            }
-            "mkword" -> {
-                val msbReg = codeGen.vmRegisters.nextFree()
-                val lsbReg = codeGen.vmRegisters.nextFree()
-                code += exprGen.translateExpression(call.args[0], msbReg)
-                code += exprGen.translateExpression(call.args[1], lsbReg)
-                code += VmCodeInstruction(Opcode.CONCAT, VmDataType.BYTE, reg1=resultRegister, reg2=msbReg, reg3=lsbReg)
-            }
-            else -> {
-                TODO("builtinfunc ${call.name}")
-//                code += VmCodeInstruction(Opcode.NOP))
-//                for (arg in call.args) {
-//                    code += translateExpression(arg, resultRegister)
-//                    code += when(arg.type) {
-//                        in ByteDatatypes -> VmCodeInstruction(Opcode.PUSH, VmDataType.BYTE, reg1=resultRegister))
-//                        in WordDatatypes -> VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1=resultRegister))
-//                        else -> throw AssemblyError("weird arg dt")
-//                    }
-//                }
-//                code += VmCodeInstruction(Opcode.CALL), labelArg = listOf("_prog8_builtin", call.name))
-//                for (arg in call.args) {
-//                    code += when(arg.type) {
-//                        in ByteDatatypes -> VmCodeInstruction(Opcode.POP, VmDataType.BYTE, reg1=resultRegister))
-//                        in WordDatatypes -> VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1=resultRegister))
-//                        else -> throw AssemblyError("weird arg dt")
-//                    }
-//                }
-//                code += VmCodeInstruction(Opcode.NOP))
+                else -> throw AssemblyError("weird type")
            }
        }
        return code
    }

+    private fun funcSgn(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += exprGen.translateExpression(call.args.single(), reg, -1)
+        code += VmCodeInstruction(Opcode.SGN, codeGen.vmType(call.type), reg1=resultRegister, reg2=reg)
+        return code
+    }
+
+    private fun funcSqrt16(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += exprGen.translateExpression(call.args.single(), reg, -1)
+        code += VmCodeInstruction(Opcode.SQRT, VmDataType.WORD, reg1=resultRegister, reg2=reg)
+        return code
+    }
+
+    private fun funcPop(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += VmCodeInstruction(Opcode.POP, VmDataType.BYTE, reg1=reg)
+        code += assignRegisterTo(call.args.single(), reg)
+        return code
+    }
+
+    private fun funcPopw(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += VmCodeInstruction(Opcode.POP, VmDataType.WORD, reg1=reg)
+        code += assignRegisterTo(call.args.single(), reg)
+        return code
+    }
+
+    private fun funcPush(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += exprGen.translateExpression(call.args.single(), reg, -1)
+        code += VmCodeInstruction(Opcode.PUSH, VmDataType.BYTE, reg1=reg)
+        return code
+    }
+
+    private fun funcPushw(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        val reg = codeGen.vmRegisters.nextFree()
+        code += exprGen.translateExpression(call.args.single(), reg, -1)
+        code += VmCodeInstruction(Opcode.PUSH, VmDataType.WORD, reg1=reg)
+        return code
+    }
+
+    private fun funcReverse(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val arrayName = call.args[0] as PtIdentifier
+        val array = codeGen.symbolTable.flat.getValue(arrayName.targetName) as StStaticVariable
+        val sortSyscall =
+            when(array.dt) {
+                DataType.ARRAY_UB, DataType.ARRAY_B, DataType.STR -> Syscall.REVERSE_BYTES
+                DataType.ARRAY_UW, DataType.ARRAY_W -> Syscall.REVERSE_WORDS
+                DataType.ARRAY_F -> Syscall.REVERSE_FLOATS
+                else -> throw IllegalArgumentException("weird type to reverse")
+            }
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args[0], 0, -1)
+        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=1, value=array.length)
+        code += VmCodeInstruction(Opcode.SYSCALL, value=sortSyscall.ordinal)
+        return code
+    }
+
+    private fun funcSort(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val arrayName = call.args[0] as PtIdentifier
+        val array = codeGen.symbolTable.flat.getValue(arrayName.targetName) as StStaticVariable
+        val sortSyscall =
+            when(array.dt) {
+                DataType.ARRAY_UB -> Syscall.SORT_UBYTE
+                DataType.ARRAY_B -> Syscall.SORT_BYTE
+                DataType.ARRAY_UW -> Syscall.SORT_UWORD
+                DataType.ARRAY_W -> Syscall.SORT_WORD
+                DataType.STR -> Syscall.SORT_UBYTE
+                DataType.ARRAY_F -> throw IllegalArgumentException("sorting a floating point array is not supported")
+                else -> throw IllegalArgumentException("weird type to sort")
+            }
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args[0], 0, -1)
+        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=1, value=array.length)
+        code += VmCodeInstruction(Opcode.SYSCALL, value=sortSyscall.ordinal)
+        return code
+    }
+
+    private fun funcMkword(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val msbReg = codeGen.vmRegisters.nextFree()
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args[0], msbReg, -1)
+        code += exprGen.translateExpression(call.args[1], resultRegister, -1)
+        code += VmCodeInstruction(Opcode.CONCAT, VmDataType.BYTE, reg1=resultRegister, reg2=msbReg)
+        return code
+    }
+
+    private fun funcPokeW(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isZero(call.args[1])) {
+            if (call.args[0] is PtNumber) {
+                val address = (call.args[0] as PtNumber).number.toInt()
+                code += VmCodeInstruction(Opcode.STOREZM, VmDataType.WORD, value = address)
+            } else {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args[0], addressReg, -1)
+                code += VmCodeInstruction(Opcode.STOREZI, VmDataType.WORD, reg2 = addressReg)
+            }
+        } else {
+            val valueReg = codeGen.vmRegisters.nextFree()
+            if (call.args[0] is PtNumber) {
+                val address = (call.args[0] as PtNumber).number.toInt()
+                code += exprGen.translateExpression(call.args[1], valueReg, -1)
+                code += VmCodeInstruction(Opcode.STOREM, VmDataType.WORD, reg1 = valueReg, value = address)
+            } else {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args[0], addressReg, -1)
+                code += exprGen.translateExpression(call.args[1], valueReg, -1)
+                code += VmCodeInstruction(Opcode.STOREI, VmDataType.WORD, reg1 = valueReg, reg2 = addressReg)
+            }
+        }
+        return code
+    }
+
+    private fun funcPoke(call: PtBuiltinFunctionCall): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isZero(call.args[1])) {
+            if (call.args[0] is PtNumber) {
+                val address = (call.args[0] as PtNumber).number.toInt()
+                code += VmCodeInstruction(Opcode.STOREZM, VmDataType.BYTE, value = address)
+            } else {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args[0], addressReg, -1)
+                code += VmCodeInstruction(Opcode.STOREZI, VmDataType.BYTE, reg2 = addressReg)
+            }
+        } else {
+            val valueReg = codeGen.vmRegisters.nextFree()
+            if (call.args[0] is PtNumber) {
+                val address = (call.args[0] as PtNumber).number.toInt()
+                code += exprGen.translateExpression(call.args[1], valueReg, -1)
+                code += VmCodeInstruction(Opcode.STOREM, VmDataType.BYTE, reg1 = valueReg, value = address)
+            } else {
+                val addressReg = codeGen.vmRegisters.nextFree()
+                code += exprGen.translateExpression(call.args[0], addressReg, -1)
+                code += exprGen.translateExpression(call.args[1], valueReg, -1)
+                code += VmCodeInstruction(Opcode.STOREI, VmDataType.BYTE, reg1 = valueReg, reg2 = addressReg)
+            }
+        }
+        return code
+    }
+
+    private fun funcPeekW(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(call.args[0] is PtNumber) {
+            val address = (call.args[0] as PtNumber).number.toInt()
+            code += VmCodeInstruction(Opcode.LOADM, VmDataType.WORD, reg1 = resultRegister, value = address)
+        } else {
+            val addressReg = codeGen.vmRegisters.nextFree()
+            code += exprGen.translateExpression(call.args.single(), addressReg, -1)
+            code += VmCodeInstruction(Opcode.LOADI, VmDataType.WORD, reg1 = resultRegister, reg2 = addressReg)
+        }
+        return code
+    }
+
+    private fun funcPeek(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(call.args[0] is PtNumber) {
+            val address = (call.args[0] as PtNumber).number.toInt()
+            code += VmCodeInstruction(Opcode.LOADM, VmDataType.BYTE, reg1 = resultRegister, value = address)
+        } else {
+            val addressReg = codeGen.vmRegisters.nextFree()
+            code += exprGen.translateExpression(call.args.single(), addressReg, -1)
+            code += VmCodeInstruction(Opcode.LOADI, VmDataType.BYTE, reg1 = resultRegister, reg2 = addressReg)
+        }
+        return code
+    }
+
+    private fun funcRnd(resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += VmCodeInstruction(Opcode.RND, VmDataType.BYTE, reg1=resultRegister)
+        return code
+    }
+
+    private fun funcRndw(resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += VmCodeInstruction(Opcode.RND, VmDataType.WORD, reg1=resultRegister)
+        return code
+    }
+
+    private fun funcMemory(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val name = (call.args[0] as PtString).value
+        val size = (call.args[1] as PtNumber).number.toUInt()
+        val align = (call.args[2] as PtNumber).number.toUInt()
+        val existing = codeGen.allocations.getMemorySlab(name)
+        val address = if(existing==null)
+            codeGen.allocations.allocateMemorySlab(name, size, align)
+        else if(existing.second!=size || existing.third!=align) {
+            codeGen.errors.err("memory slab '$name' already exists with a different size or alignment", call.position)
+            return VmCodeChunk()
+        }
+        else
+            existing.first
+        val code = VmCodeChunk()
+        code += VmCodeInstruction(Opcode.LOAD, VmDataType.WORD, reg1=resultRegister, value=address.toInt())
+        return code
+    }
+
+    private fun funcLsb(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args.single(), resultRegister, -1)
+        // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
+        return code
+    }
+
+    private fun funcMsb(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args.single(), resultRegister, -1)
+        code += VmCodeInstruction(Opcode.MSIG, VmDataType.BYTE, reg1 = resultRegister, reg2=resultRegister)
+        // note: if a word result is needed, the upper byte is cleared by the typecast that follows. No need to do it here.
+        return code
+    }
+
+    private fun funcRolRor(opcode: Opcode, call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk {
+        val vmDt = codeGen.vmType(call.args[0].type)
+        val code = VmCodeChunk()
+        code += exprGen.translateExpression(call.args[0], resultRegister, -1)
+        code += VmCodeInstruction(opcode, vmDt, reg1=resultRegister)
+        code += assignRegisterTo(call.args[0], resultRegister)
+        return code
+    }
+
+    private fun assignRegisterTo(target: PtExpression, register: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val assignment = PtAssignment(target.position)
+        val assignTarget = PtAssignTarget(target.position)
+        assignTarget.children.add(target)
+        assignment.children.add(assignTarget)
+        assignment.children.add(PtMachineRegister(register, target.type, target.position))
+        code += codeGen.translateNode(assignment)
+        return code
+    }
 }
@@ -10,15 +10,25 @@ import kotlin.math.pow


 internal class VmRegisterPool {
-    private var firstFree: Int=3    // registers 0,1,2 are reserved
-    
+    private var firstFree: Int=3        // integer registers 0,1,2 are reserved
+    private var firstFreeFloat: Int=0
+
    fun peekNext() = firstFree
+    fun peekNextFloat() = firstFreeFloat

    fun nextFree(): Int {
        val result = firstFree
        firstFree++
        if(firstFree>65535)
-            throw AssemblyError("out of virtual registers")
+            throw AssemblyError("out of virtual registers (int)")
+        return result
+    }
+
+    fun nextFreeFloat(): Int {
+        val result = firstFreeFloat
+        firstFreeFloat++
+        if(firstFreeFloat>65535)
+            throw AssemblyError("out of virtual registers (fp)")
        return result
    }
 }
@@ -30,37 +40,45 @@ class CodeGen(internal val program: PtProgram,
              internal val errors: IErrorReporter
 ): IAssemblyGenerator {

-    internal val allocations = VariableAllocator(symbolTable, program, errors)
+    internal val allocations = VariableAllocator(symbolTable, program)
    private val expressionEval = ExpressionGen(this)
    private val builtinFuncGen = BuiltinFuncGen(this, expressionEval)
+    private val assignmentGen = AssignmentGen(this, expressionEval)
    internal val vmRegisters = VmRegisterPool()

-    init {
-        if(options.dontReinitGlobals)
-            TODO("support no globals re-init in vm")
-    }
-
    override fun compileToAssembly(): IAssemblyProgram? {
        val vmprog = AssemblyProgram(program.name, allocations)

-        // collect global variables initializers
-        program.allBlocks().forEach {
-            val code = VmCodeChunk()
-            it.children.filterIsInstance<PtAssignment>().forEach { assign -> code += translate(assign) }
-            vmprog.addGlobalInits(code)
+        if(!options.dontReinitGlobals) {
+            // collect global variables initializers
+            program.allBlocks().forEach {
+                val code = VmCodeChunk()
+                it.children.filterIsInstance<PtAssignment>().forEach { assign -> code += assignmentGen.translate(assign) }
+                vmprog.addGlobalInits(code)
+            }
        }

+        if(options.symbolDefs.isNotEmpty())
+            throw AssemblyError("virtual target doesn't support symbols defined on the commandline")
+        if(options.evalStackBaseAddress!=null)
+            throw AssemblyError("virtual target doesn't use eval-stack")
+
        for (block in program.allBlocks()) {
            vmprog.addBlock(translate(block))
        }

-        println("Vm codegen: amount of vm registers=${vmRegisters.peekNext()}")
+        if(options.optimize) {
+            val optimizer = VmPeepholeOptimizer(vmprog, allocations)
+            optimizer.optimize()
+        }
+
+        println("Vm codegen: virtual registers=${vmRegisters.peekNext()} memory usage=${allocations.freeMem}")

        return vmprog
    }


-    private fun translateNode(node: PtNode): VmCodeChunk {
+    internal fun translateNode(node: PtNode): VmCodeChunk {
        val code = when(node) {
            is PtBlock -> translate(node)
            is PtSub -> translate(node)
@@ -68,21 +86,24 @@ class CodeGen(internal val program: PtProgram,
            is PtVariable -> VmCodeChunk() // var should be looked up via symbol table
            is PtMemMapped -> VmCodeChunk() // memmapped var should be looked up via symbol table
            is PtConstant -> VmCodeChunk() // constants have all been folded into the code
-            is PtAssignment -> translate(node)
+            is PtAssignment -> assignmentGen.translate(node)
            is PtNodeGroup -> translateGroup(node.children)
            is PtBuiltinFunctionCall -> translateBuiltinFunc(node, 0)
-            is PtFunctionCall -> expressionEval.translate(node, 0)
+            is PtFunctionCall -> expressionEval.translate(node, 0, 0)
            is PtNop -> VmCodeChunk()
            is PtReturn -> translate(node)
            is PtJump -> translate(node)
            is PtWhen -> translate(node)
-            is PtPipe -> expressionEval.translate(node, 0)
            is PtForLoop -> translate(node)
            is PtIfElse -> translate(node)
            is PtPostIncrDecr -> translate(node)
            is PtRepeatLoop -> translate(node)
            is PtLabel -> VmCodeChunk(VmCodeLabel(node.scopedName))
            is PtBreakpoint -> VmCodeChunk(VmCodeInstruction(Opcode.BREAKPOINT))
+            is PtConditionalBranch -> translate(node)
+            is PtInlineAssembly -> VmCodeChunk(VmCodeInlineAsm(node.assembly))
+            is PtIncludeBinary -> VmCodeChunk(VmCodeInlineBinary(node.file, node.offset, node.length))
+            is PtAsmSub -> TODO("asmsub not yet supported on virtual machine target ${node.position}")
            is PtAddressOf,
            is PtContainmentCheck,
            is PtMemoryByte,
@@ -98,11 +119,7 @@ class CodeGen(internal val program: PtProgram,
            is PtSubroutineParameter,
            is PtNumber,
            is PtArray,
-            is PtString -> throw AssemblyError("strings should not occur as separate statement node ${node.position}")
-            is PtAsmSub -> throw AssemblyError("asmsub not supported on virtual machine target ${node.position}")
-            is PtInlineAssembly -> throw AssemblyError("inline assembly not supported on virtual machine target ${node.position}")
-            is PtIncludeBinary -> throw AssemblyError("inline binary data not supported on virtual machine target ${node.position}")
-            is PtConditionalBranch -> throw AssemblyError("conditional branches not supported in vm target due to lack of cpu flags ${node.position}")
+            is PtString -> throw AssemblyError("should not occur as separate statement node ${node.position}")
            else -> TODO("missing codegen for $node")
        }
        if(code.lines.isNotEmpty() && node.position.line!=0)
@@ -110,6 +127,33 @@ class CodeGen(internal val program: PtProgram,
        return code
    }

+    private fun translate(branch: PtConditionalBranch): VmCodeChunk {
+        val code = VmCodeChunk()
+        val elseLabel = createLabelName()
+        // note that the branch opcode used is the opposite as the branch condition, because the generated code jumps to the 'else' part
+        code += when(branch.condition) {
+            BranchCondition.CS -> VmCodeInstruction(Opcode.BSTCC, labelSymbol = elseLabel)
+            BranchCondition.CC -> VmCodeInstruction(Opcode.BSTCS, labelSymbol = elseLabel)
+            BranchCondition.EQ, BranchCondition.Z -> VmCodeInstruction(Opcode.BSTNE, labelSymbol = elseLabel)
+            BranchCondition.NE, BranchCondition.NZ -> VmCodeInstruction(Opcode.BSTEQ, labelSymbol = elseLabel)
+            BranchCondition.MI, BranchCondition.NEG -> VmCodeInstruction(Opcode.BSTPOS, labelSymbol = elseLabel)
+            BranchCondition.PL, BranchCondition.POS -> VmCodeInstruction(Opcode.BSTNEG, labelSymbol = elseLabel)
+            BranchCondition.VC,
+            BranchCondition.VS -> throw AssemblyError("conditional branch ${branch.condition} not supported in vm target due to lack of cpu V flag ${branch.position}")
+        }
+        code += translateNode(branch.trueScope)
+        if(branch.falseScope.children.isNotEmpty()) {
+            val endLabel = createLabelName()
+            code += VmCodeInstruction(Opcode.JUMP, labelSymbol = endLabel)
+            code += VmCodeLabel(elseLabel)
+            code += translateNode(branch.falseScope)
+            code += VmCodeLabel(endLabel)
+        } else {
+            code += VmCodeLabel(elseLabel)
+        }
+        return code
+    }
+
    private fun translate(whenStmt: PtWhen): VmCodeChunk {
        if(whenStmt.choices.children.isEmpty())
            return VmCodeChunk()
@@ -117,7 +161,7 @@ class CodeGen(internal val program: PtProgram,
        val valueReg = vmRegisters.nextFree()
        val choiceReg = vmRegisters.nextFree()
        val valueDt = vmType(whenStmt.value.type)
-        code += expressionEval.translateExpression(whenStmt.value, valueReg)
+        code += expressionEval.translateExpression(whenStmt.value, valueReg, -1)
        val choices = whenStmt.choices.children.map {it as PtWhenChoice }
        val endLabel = createLabelName()
        for (choice in choices) {
@@ -128,21 +172,21 @@ class CodeGen(internal val program: PtProgram,
                val values = choice.values.children.map {it as PtNumber}
                if(values.size==1) {
                    code += VmCodeInstruction(Opcode.LOAD, valueDt, reg1=choiceReg, value=values[0].number.toInt())
-                    code += VmCodeInstruction(Opcode.BNE, valueDt, reg1=valueReg, reg2=choiceReg, symbol = skipLabel)
+                    code += VmCodeInstruction(Opcode.BNE, valueDt, reg1=valueReg, reg2=choiceReg, labelSymbol = skipLabel)
                    code += translateNode(choice.statements)
                    if(choice.statements.children.last() !is PtReturn)
-                        code += VmCodeInstruction(Opcode.JUMP, symbol = endLabel)
+                        code += VmCodeInstruction(Opcode.JUMP, labelSymbol = endLabel)
                } else {
                    val matchLabel = createLabelName()
                    for (value in values) {
                        code += VmCodeInstruction(Opcode.LOAD, valueDt, reg1=choiceReg, value=value.number.toInt())
-                        code += VmCodeInstruction(Opcode.BEQ, valueDt, reg1=valueReg, reg2=choiceReg, symbol = matchLabel)
+                        code += VmCodeInstruction(Opcode.BEQ, valueDt, reg1=valueReg, reg2=choiceReg, labelSymbol = matchLabel)
                    }
-                    code += VmCodeInstruction(Opcode.JUMP, symbol = skipLabel)
+                    code += VmCodeInstruction(Opcode.JUMP, labelSymbol = skipLabel)
                    code += VmCodeLabel(matchLabel)
                    code += translateNode(choice.statements)
                    if(choice.statements.children.last() !is PtReturn)
-                        code += VmCodeInstruction(Opcode.JUMP, symbol = endLabel)
+                        code += VmCodeInstruction(Opcode.JUMP, labelSymbol = endLabel)
                }
                code += VmCodeLabel(skipLabel)
            }
@@ -167,35 +211,46 @@ class CodeGen(internal val program: PtProgram,
                val iterableVar = symbolTable.lookup(iterable.targetName) as StStaticVariable
                val loopvarAddress = allocations.get(loopvar.scopedName)
                val indexReg = vmRegisters.nextFree()
+                val tmpReg = vmRegisters.nextFree()
                val loopLabel = createLabelName()
                val endLabel = createLabelName()
                if(iterableVar.dt==DataType.STR) {
                    // iterate over a zero-terminated string
                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
                    code += VmCodeLabel(loopLabel)
-                    code += VmCodeInstruction(Opcode.LOADX, VmDataType.BYTE, reg1=0, reg2=indexReg, value = arrayAddress)
-                    code += VmCodeInstruction(Opcode.BZ, VmDataType.BYTE, reg1=0, symbol = endLabel)
-                    code += VmCodeInstruction(Opcode.STOREM, VmDataType.BYTE, reg1=0, value = loopvarAddress)
+                    code += VmCodeInstruction(Opcode.LOADX, VmDataType.BYTE, reg1=tmpReg, reg2=indexReg, value = arrayAddress)
+                    code += VmCodeInstruction(Opcode.BZ, VmDataType.BYTE, reg1=tmpReg, labelSymbol = endLabel)
+                    code += VmCodeInstruction(Opcode.STOREM, VmDataType.BYTE, reg1=tmpReg, value = loopvarAddress)
                    code += translateNode(forLoop.statements)
                    code += VmCodeInstruction(Opcode.INC, VmDataType.BYTE, reg1=indexReg)
-                    code += VmCodeInstruction(Opcode.JUMP, symbol = loopLabel)
+                    code += VmCodeInstruction(Opcode.JUMP, labelSymbol = loopLabel)
                    code += VmCodeLabel(endLabel)
                } else {
                    // iterate over array
                    val elementDt = ArrayToElementTypes.getValue(iterable.type)
                    val elementSize = program.memsizer.memorySize(elementDt)
                    val lengthBytes = iterableVar.length!! * elementSize
-                    val lengthReg = vmRegisters.nextFree()
-                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
-                    code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=lengthReg, value=lengthBytes)
-                    code += VmCodeLabel(loopLabel)
-                    code += VmCodeInstruction(Opcode.BEQ, VmDataType.BYTE, reg1=indexReg, reg2=lengthReg, symbol = endLabel)
-                    code += VmCodeInstruction(Opcode.LOADX, vmType(elementDt), reg1=0, reg2=indexReg, value=arrayAddress)
-                    code += VmCodeInstruction(Opcode.STOREM, vmType(elementDt), reg1=0, value = loopvarAddress)
-                    code += translateNode(forLoop.statements)
-                    code += addConstReg(VmDataType.BYTE, indexReg, elementSize)
-                    code += VmCodeInstruction(Opcode.JUMP, symbol = loopLabel)
-                    code += VmCodeLabel(endLabel)
+                    if(lengthBytes<256) {
+                        val lengthReg = vmRegisters.nextFree()
+                        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
+                        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=lengthReg, value=lengthBytes)
+                        code += VmCodeLabel(loopLabel)
+                        code += VmCodeInstruction(Opcode.LOADX, vmType(elementDt), reg1=tmpReg, reg2=indexReg, value=arrayAddress)
+                        code += VmCodeInstruction(Opcode.STOREM, vmType(elementDt), reg1=tmpReg, value = loopvarAddress)
+                        code += translateNode(forLoop.statements)
+                        code += addConstReg(VmDataType.BYTE, indexReg, elementSize)
+                        code += VmCodeInstruction(Opcode.BNE, VmDataType.BYTE, reg1=indexReg, reg2=lengthReg, labelSymbol = loopLabel)
+                    } else if(lengthBytes==256) {
+                        code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=indexReg, value=0)
+                        code += VmCodeLabel(loopLabel)
+                        code += VmCodeInstruction(Opcode.LOADX, vmType(elementDt), reg1=tmpReg, reg2=indexReg, value=arrayAddress)
+                        code += VmCodeInstruction(Opcode.STOREM, vmType(elementDt), reg1=tmpReg, value = loopvarAddress)
+                        code += translateNode(forLoop.statements)
+                        code += addConstReg(VmDataType.BYTE, indexReg, elementSize)
+                        code += VmCodeInstruction(Opcode.BNZ, VmDataType.BYTE, reg1=indexReg, labelSymbol = loopLabel)
+                    } else {
+                        throw AssemblyError("iterator length should never exceed 256")
+                    }
                }
            }
            else -> throw AssemblyError("weird for iterable")
@@ -215,8 +270,8 @@ class CodeGen(internal val program: PtProgram,
        val loopLabel = createLabelName()
        val code = VmCodeChunk()

-        code += expressionEval.translateExpression(iterable.to, endvalueReg)
-        code += expressionEval.translateExpression(iterable.from, indexReg)
+        code += expressionEval.translateExpression(iterable.to, endvalueReg, -1)
+        code += expressionEval.translateExpression(iterable.from, indexReg, -1)
        code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1=indexReg, value=loopvarAddress)
        code += VmCodeLabel(loopLabel)
        code += translateNode(forLoop.statements)
@@ -224,46 +279,56 @@ class CodeGen(internal val program: PtProgram,
            code += addConstMem(loopvarDt, loopvarAddress.toUInt(), step)
            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
        } else {
+            // TODO WHY THID DISTINCTION?
            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
            code += addConstReg(loopvarDt, indexReg, step)
            code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
        }
        val branchOpcode = if(loopvar.dt in SignedDatatypes) Opcode.BLES else Opcode.BLE
-        code += VmCodeInstruction(branchOpcode, loopvarDt, reg1=indexReg, reg2=endvalueReg, symbol=loopLabel)
+        code += VmCodeInstruction(branchOpcode, loopvarDt, reg1=indexReg, reg2=endvalueReg, labelSymbol=loopLabel)
        return code
    }

    private fun translateForInConstantRange(forLoop: PtForLoop, loopvar: StStaticVariable): VmCodeChunk {
-        val iterable = forLoop.iterable as PtRange
-        val step = iterable.step.number.toInt()
-        val range = IntProgression.fromClosedRange(
-            (iterable.from as PtNumber).number.toInt(),
-            (iterable.to as PtNumber).number.toInt() + step,
-            step)
-        if (range.isEmpty() || range.step==0)
-            throw AssemblyError("empty range or step 0")
-
        val loopLabel = createLabelName()
        val loopvarAddress = allocations.get(loopvar.scopedName)
        val indexReg = vmRegisters.nextFree()
-        val endvalueReg = vmRegisters.nextFree()
        val loopvarDt = vmType(loopvar.dt)
+        val iterable = forLoop.iterable as PtRange
+        val step = iterable.step.number.toInt()
+        val rangeStart = (iterable.from as PtNumber).number.toInt()
+        val rangeEndUntyped = (iterable.to as PtNumber).number.toInt() + step
+        if(step==0)
+            throw AssemblyError("step 0")
+        if(step>0 && rangeEndUntyped<rangeStart || step<0 && rangeEndUntyped>rangeStart)
+            throw AssemblyError("empty range")
+        val rangeEndWrapped = if(loopvarDt==VmDataType.BYTE) rangeEndUntyped and 255 else rangeEndUntyped and 65535
        val code = VmCodeChunk()
-        code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1=endvalueReg, value=range.last)
-        code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1=indexReg, value=range.first)
+        val endvalueReg: Int
+        if(rangeEndWrapped!=0) {
+            endvalueReg = vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1 = endvalueReg, value = rangeEndWrapped)
+        } else {
+            endvalueReg = -1 // not used
+        }
+        code += VmCodeInstruction(Opcode.LOAD, loopvarDt, reg1=indexReg, value=rangeStart)
        code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1=indexReg, value=loopvarAddress)
        code += VmCodeLabel(loopLabel)
        code += translateNode(forLoop.statements)
-        if(range.step<3) {
-            code += addConstMem(loopvarDt, loopvarAddress.toUInt(), range.step)
+        if(step<3) {
+            code += addConstMem(loopvarDt, loopvarAddress.toUInt(), step)
            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
        } else {
+            // TODO WHY THIS DISTICTION ?
            code += VmCodeInstruction(Opcode.LOADM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
-            code += addConstReg(loopvarDt, indexReg, range.step)
+            code += addConstReg(loopvarDt, indexReg, step)
            code += VmCodeInstruction(Opcode.STOREM, loopvarDt, reg1 = indexReg, value = loopvarAddress)
        }
-        // TODO more optimal loop instruction for loops ending on 0 (BNZ?)
-        code += VmCodeInstruction(Opcode.BNE, loopvarDt, reg1=indexReg, reg2=endvalueReg, symbol=loopLabel)
+        code += if(rangeEndWrapped==0) {
+            VmCodeInstruction(Opcode.BNZ, loopvarDt, reg1 = indexReg, labelSymbol = loopLabel)
+        } else {
+            VmCodeInstruction(Opcode.BNE, loopvarDt, reg1 = indexReg, reg2 = endvalueReg, labelSymbol = loopLabel)
+        }
        return code
    }

@@ -286,14 +351,10 @@ class CodeGen(internal val program: PtProgram,
                code += VmCodeInstruction(Opcode.DEC, dt, reg1=reg)
            }
            else -> {
-                val valueReg = vmRegisters.nextFree()
-                if(value>0) {
-                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=valueReg, value= value)
-                    code += VmCodeInstruction(Opcode.ADD, dt, reg1 = reg, reg2 = reg, reg3 = valueReg)
-                }
-                else {
-                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=valueReg, value= -value)
-                    code += VmCodeInstruction(Opcode.SUB, dt, reg1 = reg, reg2 = reg, reg3 = valueReg)
+                code += if(value>0) {
+                    VmCodeInstruction(Opcode.ADD, dt, reg1 = reg, value=value)
+                } else {
+                    VmCodeInstruction(Opcode.SUB, dt, reg1 = reg, value=-value)
                }
            }
        }
@@ -324,13 +385,13 @@ class CodeGen(internal val program: PtProgram,
                if(value>0) {
                    code += VmCodeInstruction(Opcode.LOADM, dt, reg1=valueReg, value=address.toInt())
                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=operandReg, value=value)
-                    code += VmCodeInstruction(Opcode.ADD, dt, reg1 = valueReg, reg2 = valueReg, reg3 = operandReg)
+                    code += VmCodeInstruction(Opcode.ADDR, dt, reg1 = valueReg, reg2 = operandReg)          // TODO USE ADDM?
                    code += VmCodeInstruction(Opcode.STOREM, dt, reg1=valueReg, value=address.toInt())
                }
                else {
                    code += VmCodeInstruction(Opcode.LOADM, dt, reg1=valueReg, value=address.toInt())
                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=operandReg, value=-value)
-                    code += VmCodeInstruction(Opcode.SUB, dt, reg1 = valueReg, reg2 = valueReg, reg3 = operandReg)
+                    code += VmCodeInstruction(Opcode.SUBR, dt, reg1 = valueReg, reg2 = operandReg)          // TODO USE ADDM?
                    code += VmCodeInstruction(Opcode.STOREM, dt, reg1=valueReg, value=address.toInt())
                }
            }
@@ -338,113 +399,323 @@ class CodeGen(internal val program: PtProgram,
        return code
    }

-    private val powersOfTwo = (0..16).map { 2.0.pow(it.toDouble()).toInt() }
-
-    private fun multiplyByConst(dt: VmDataType, reg: Int, factor: UInt): VmCodeChunk {
+    internal fun multiplyByConstFloat(fpReg: Int, factor: Float): VmCodeChunk {
        val code = VmCodeChunk()
-        val pow2 = powersOfTwo.indexOf(factor.toInt())
-        if(pow2>=1) {
-            // just shift bits
-            code += VmCodeInstruction(Opcode.LSL, dt, reg1=reg, reg2=reg, reg3=pow2)
+        if(factor==1f)
+            return code
+        code += if(factor==0f) {
+            VmCodeInstruction(Opcode.LOAD, VmDataType.FLOAT, fpReg1 = fpReg, fpValue = 0f)
        } else {
-            when(factor) {
-                0u -> {
-                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=reg, value=0)
-                }
-                1u -> { /* do nothing */ }
-                else -> {
-                    val factorReg = vmRegisters.nextFree()
-                    code += VmCodeInstruction(Opcode.LOAD, dt, reg1=factorReg, value=factor.toInt())
-                    code += VmCodeInstruction(Opcode.MUL, dt, reg1=reg, reg2=reg, reg3=factorReg)
-                }
+            VmCodeInstruction(Opcode.MUL, VmDataType.FLOAT, fpReg1 = fpReg, fpValue=factor)
+        }
+        return code
+    }
+
+    internal fun multiplyByConstFloatInplace(address: Int, factor: Float): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1f)
+            return code
+        if(factor==0f) {
+            code += VmCodeInstruction(Opcode.STOREZM, VmDataType.FLOAT, value = address)
+        } else {
+            val factorReg = vmRegisters.nextFreeFloat()
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.FLOAT, fpReg1=factorReg, fpValue = factor)
+            code += VmCodeInstruction(Opcode.MULM, VmDataType.FLOAT, fpReg1 = factorReg, value = address)
+        }
+        return code
+    }
+
+    internal val powersOfTwo = (0..16).map { 2.0.pow(it.toDouble()).toInt() }
+
+    internal fun multiplyByConst(dt: VmDataType, reg: Int, factor: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1)
+            return code
+        val pow2 = powersOfTwo.indexOf(factor)
+        if(pow2==1) {
+            // just shift 1 bit
+            code += VmCodeInstruction(Opcode.LSL, dt, reg1=reg)
+        }
+        else if(pow2>=1) {
+            // just shift multiple bits
+            val pow2reg = vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, dt, reg1=pow2reg, value=pow2)
+            code += VmCodeInstruction(Opcode.LSLN, dt, reg1=reg, reg2=pow2reg)
+        } else {
+            code += if (factor == 0) {
+                VmCodeInstruction(Opcode.LOAD, dt, reg1=reg, value=0)
+            } else {
+                VmCodeInstruction(Opcode.MUL, dt, reg1=reg, value=factor)
+            }
+        }
+        return code
+    }
+
+    internal fun multiplyByConstInplace(dt: VmDataType, address: Int, factor: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1)
+            return code
+        val pow2 = powersOfTwo.indexOf(factor)
+        if(pow2==1) {
+            // just shift 1 bit
+            code += VmCodeInstruction(Opcode.LSLM, dt, value = address)
+        }
+        else if(pow2>=1) {
+            // just shift multiple bits
+            val pow2reg = vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, dt, reg1=pow2reg, value=pow2)
+            code += VmCodeInstruction(Opcode.LSLNM, dt, reg1=pow2reg, value=address)
+        } else {
+            if (factor == 0) {
+                code += VmCodeInstruction(Opcode.STOREZM, dt, value=address)
+            }
+            else {
+                val factorReg = vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, dt, reg1=factorReg, value = factor)
+                code += VmCodeInstruction(Opcode.MULM, dt, reg1=factorReg, value = address)
+            }
+        }
+        return code
+    }
+
+    internal fun divideByConstFloat(fpReg: Int, factor: Float): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1f)
+            return code
+        code += if(factor==0f) {
+            VmCodeInstruction(Opcode.LOAD, VmDataType.FLOAT, fpReg1 = fpReg, fpValue = Float.MAX_VALUE)
+        } else {
+            VmCodeInstruction(Opcode.DIVS, VmDataType.FLOAT, fpReg1 = fpReg, fpValue=factor)
+        }
+        return code
+    }
+
+    internal fun divideByConstFloatInplace(address: Int, factor: Float): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1f)
+            return code
+        if(factor==0f) {
+            val maxvalueReg = vmRegisters.nextFreeFloat()
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.FLOAT, fpReg1 = maxvalueReg, fpValue = Float.MAX_VALUE)
+            code += VmCodeInstruction(Opcode.STOREM, VmDataType.FLOAT, fpReg1 = maxvalueReg, value=address)
+        } else {
+            val factorReg = vmRegisters.nextFreeFloat()
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.FLOAT, fpReg1=factorReg, fpValue = factor)
+            code += VmCodeInstruction(Opcode.DIVSM, VmDataType.FLOAT, fpReg1 = factorReg, value=address)
+        }
+        return code
+    }
+
+    internal fun divideByConst(dt: VmDataType, reg: Int, factor: Int, signed: Boolean): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1)
+            return code
+        val pow2 = powersOfTwo.indexOf(factor)
+        if(pow2==1) {
+            // just shift 1 bit
+            code += if(signed)
+                VmCodeInstruction(Opcode.ASR, dt, reg1=reg)
+            else
+                VmCodeInstruction(Opcode.LSR, dt, reg1=reg)
+        }
+        else if(pow2>=1) {
+            // just shift multiple bits
+            val pow2reg = vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, dt, reg1=pow2reg, value=pow2)
+            code += if(signed)
+                VmCodeInstruction(Opcode.ASRN, dt, reg1=reg, reg2=pow2reg)
+            else
+                VmCodeInstruction(Opcode.LSRN, dt, reg1=reg, reg2=pow2reg)
+        } else {
+            code += if (factor == 0) {
+                VmCodeInstruction(Opcode.LOAD, dt, reg1=reg, value=0xffff)
+            } else {
+                if(signed)
+                    VmCodeInstruction(Opcode.DIVS, dt, reg1=reg, value=factor)
+                else
+                    VmCodeInstruction(Opcode.DIV, dt, reg1=reg, value=factor)
+            }
+        }
+        return code
+    }
+
+    internal fun divideByConstInplace(dt: VmDataType, address: Int, factor: Int, signed: Boolean): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(factor==1)
+            return code
+        val pow2 = powersOfTwo.indexOf(factor)
+        if(pow2==1) {
+            // just shift 1 bit
+            code += if(signed)
+                VmCodeInstruction(Opcode.ASRM, dt, value=address)
+            else
+                VmCodeInstruction(Opcode.LSRM, dt, value=address)
+        }
+        else if(pow2>=1) {
+            // just shift multiple bits
+            val pow2reg = vmRegisters.nextFree()
+            code += VmCodeInstruction(Opcode.LOAD, dt, reg1=pow2reg, value=pow2)
+            code += if(signed)
+                VmCodeInstruction(Opcode.ASRNM, dt, reg1=pow2reg, value=address)
+            else
+                VmCodeInstruction(Opcode.LSRNM, dt, reg1=pow2reg, value=address)
+        } else {
+            if (factor == 0) {
+                val reg = vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, dt, reg1=reg, value=0xffff)
+                code += VmCodeInstruction(Opcode.STOREM, dt, reg1=reg, value=address)
+            }
+            else {
+                val factorReg = vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, dt, reg1=factorReg, value= factor)
+                code += if(signed)
+                    VmCodeInstruction(Opcode.DIVSM, dt, reg1=factorReg, value=address)
+                else
+                    VmCodeInstruction(Opcode.DIVM, dt, reg1=factorReg, value=address)
            }
        }
        return code
    }

    private fun translate(ifElse: PtIfElse): VmCodeChunk {
-        var branch = Opcode.BZ
-        var condition = ifElse.condition
+        if(ifElse.condition.operator !in ComparisonOperators)
+            throw AssemblyError("if condition should only be a binary comparison expression")

-        val cond = ifElse.condition as? PtBinaryExpression
-        if((cond?.right as? PtNumber)?.number==0.0) {
-            if(cond.operator == "==") {
-                // if X==0 ...   so we branch on Not-zero instead.
-                branch = Opcode.BNZ
-                condition = cond.left
-            }
-            else if(cond.operator == "!=") {
-                // if X!=0 ...   so we keep branching on Zero.
-                condition = cond.left
-            }
-        }
-
-        val conditionReg = vmRegisters.nextFree()
-        val vmDt = vmType(condition.type)
+        val signed = ifElse.condition.left.type in arrayOf(DataType.BYTE, DataType.WORD, DataType.FLOAT)
+        val vmDt = vmType(ifElse.condition.left.type)
        val code = VmCodeChunk()
-        code += expressionEval.translateExpression(condition, conditionReg)
-        if(ifElse.elseScope.children.isNotEmpty()) {
-            // if and else parts
-            val elseLabel = createLabelName()
-            val afterIfLabel = createLabelName()
-            code += VmCodeInstruction(branch, vmDt, reg1=conditionReg, symbol = elseLabel)
-            code += translateNode(ifElse.ifScope)
-            code += VmCodeInstruction(Opcode.JUMP, symbol = afterIfLabel)
-            code += VmCodeLabel(elseLabel)
-            code += translateNode(ifElse.elseScope)
-            code += VmCodeLabel(afterIfLabel)
-        } else {
-            // only if part
-            val afterIfLabel = createLabelName()
-            code += VmCodeInstruction(branch, vmDt, reg1=conditionReg, symbol = afterIfLabel)
-            code += translateNode(ifElse.ifScope)
-            code += VmCodeLabel(afterIfLabel)
+
+        fun translateNonZeroComparison(): VmCodeChunk {
+            val elseBranch = when(ifElse.condition.operator) {
+                "==" -> Opcode.BNE
+                "!=" -> Opcode.BEQ
+                "<" -> if(signed) Opcode.BGES else Opcode.BGE
+                ">" -> if(signed) Opcode.BLES else Opcode.BLE
+                "<=" -> if(signed) Opcode.BGTS else Opcode.BGT
+                ">=" -> if(signed) Opcode.BLTS else Opcode.BLT
+                else -> throw AssemblyError("invalid comparison operator")
+            }
+
+            val leftReg = vmRegisters.nextFree()
+            val rightReg = vmRegisters.nextFree()
+            code += expressionEval.translateExpression(ifElse.condition.left, leftReg, -1)
+            code += expressionEval.translateExpression(ifElse.condition.right, rightReg, -1)
+            if(ifElse.elseScope.children.isNotEmpty()) {
+                // if and else parts
+                val elseLabel = createLabelName()
+                val afterIfLabel = createLabelName()
+                code += VmCodeInstruction(elseBranch, vmDt, reg1=leftReg, reg2=rightReg, labelSymbol = elseLabel)
+                code += translateNode(ifElse.ifScope)
+                code += VmCodeInstruction(Opcode.JUMP, labelSymbol = afterIfLabel)
+                code += VmCodeLabel(elseLabel)
+                code += translateNode(ifElse.elseScope)
+                code += VmCodeLabel(afterIfLabel)
+            } else {
+                // only if part
+                val afterIfLabel = createLabelName()
+                code += VmCodeInstruction(elseBranch, vmDt, reg1=leftReg, reg2=rightReg, labelSymbol = afterIfLabel)
+                code += translateNode(ifElse.ifScope)
+                code += VmCodeLabel(afterIfLabel)
+            }
+            return code
        }
-        return code
+
+        fun translateZeroComparison(): VmCodeChunk {
+            fun equalOrNotEqualZero(elseBranch: Opcode): VmCodeChunk {
+                val leftReg = vmRegisters.nextFree()
+                code += expressionEval.translateExpression(ifElse.condition.left, leftReg, -1)
+                if(ifElse.elseScope.children.isNotEmpty()) {
+                    // if and else parts
+                    val elseLabel = createLabelName()
+                    val afterIfLabel = createLabelName()
+                    code += VmCodeInstruction(elseBranch, vmDt, reg1=leftReg, labelSymbol = elseLabel)
+                    code += translateNode(ifElse.ifScope)
+                    code += VmCodeInstruction(Opcode.JUMP, labelSymbol = afterIfLabel)
+                    code += VmCodeLabel(elseLabel)
+                    code += translateNode(ifElse.elseScope)
+                    code += VmCodeLabel(afterIfLabel)
+                } else {
+                    // only if part
+                    val afterIfLabel = createLabelName()
+                    code += VmCodeInstruction(elseBranch, vmDt, reg1=leftReg, labelSymbol = afterIfLabel)
+                    code += translateNode(ifElse.ifScope)
+                    code += VmCodeLabel(afterIfLabel)
+                }
+                return code
+            }
+
+            return when (ifElse.condition.operator) {
+                "==" -> {
+                    // if X==0 ...   so we just branch on left expr is Not-zero.
+                    equalOrNotEqualZero(Opcode.BNZ)
+                }
+                "!=" -> {
+                    // if X!=0 ...   so we just branch on left expr is Zero.
+                    equalOrNotEqualZero(Opcode.BZ)
+                }
+                else -> {
+                    // another comparison against 0, just use regular codegen for this.
+                    translateNonZeroComparison()
+                }
+            }
+        }
+
+        return if(constValue(ifElse.condition.right)==0.0)
+            translateZeroComparison()
+        else
+            translateNonZeroComparison()
    }

+
    private fun translate(postIncrDecr: PtPostIncrDecr): VmCodeChunk {
        val code = VmCodeChunk()
-        val operation = when(postIncrDecr.operator) {
-            "++" -> Opcode.INC
-            "--" -> Opcode.DEC
+        val operationMem: Opcode
+        val operationRegister: Opcode
+        when(postIncrDecr.operator) {
+            "++" -> {
+                operationMem = Opcode.INCM
+                operationRegister = Opcode.INC
+            }
+            "--" -> {
+                operationMem = Opcode.DECM
+                operationRegister = Opcode.DEC
+            }
            else -> throw AssemblyError("weird operator")
        }
        val ident = postIncrDecr.target.identifier
        val memory = postIncrDecr.target.memory
        val array = postIncrDecr.target.array
        val vmDt = vmType(postIncrDecr.target.type)
-        val resultReg = vmRegisters.nextFree()
        if(ident!=null) {
            val address = allocations.get(ident.targetName)
-            code += VmCodeInstruction(Opcode.LOADM, vmDt, reg1=resultReg, value = address)
-            code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
-            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultReg, value = address)
+            code += VmCodeInstruction(operationMem, vmDt, value = address)
        } else if(memory!=null) {
-            val addressReg = vmRegisters.nextFree()
-            code += expressionEval.translateExpression(memory.address, addressReg)
-            code += VmCodeInstruction(Opcode.LOADI, vmDt, reg1=resultReg, reg2=addressReg)
-            code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
-            code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1=resultReg, reg2=addressReg)
+            if(memory.address is PtNumber) {
+                val address = (memory.address as PtNumber).number.toInt()
+                code += VmCodeInstruction(operationMem, vmDt, value = address)
+            } else {
+                val incReg = vmRegisters.nextFree()
+                val addressReg = vmRegisters.nextFree()
+                code += expressionEval.translateExpression(memory.address, addressReg, -1)
+                code += VmCodeInstruction(Opcode.LOADI, vmDt, reg1 = incReg, reg2 = addressReg)
+                code += VmCodeInstruction(operationRegister, vmDt, reg1 = incReg)
+                code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1 = incReg, reg2 = addressReg)
+            }
        } else if (array!=null) {
            val variable = array.variable.targetName
            var variableAddr = allocations.get(variable)
            val itemsize = program.memsizer.memorySize(array.type)
-            val fixedIndex = (array.index as? PtNumber)?.number?.toInt()
-            val memOp = when(postIncrDecr.operator) {
-                "++" -> Opcode.INCM
-                "--" -> Opcode.DECM
-                else -> throw AssemblyError("weird operator")
-            }
+            val fixedIndex = constIntValue(array.index)
            if(fixedIndex!=null) {
                variableAddr += fixedIndex*itemsize
-                code += VmCodeInstruction(memOp, vmDt, value=variableAddr)
+                code += VmCodeInstruction(operationMem, vmDt, value=variableAddr)
            } else {
+                val incReg = vmRegisters.nextFree()
                val indexReg = vmRegisters.nextFree()
-                code += expressionEval.translateExpression(array.index, indexReg)
-                code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=resultReg, reg2=indexReg, value=variableAddr)
-                code += VmCodeInstruction(operation, vmDt, reg1=resultReg)
-                code += VmCodeInstruction(Opcode.STOREX, vmDt, reg1=resultReg, reg2=indexReg, value=variableAddr)
+                code += expressionEval.translateExpression(array.index, indexReg, -1)
+                code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=incReg, reg2=indexReg, value=variableAddr)
+                code += VmCodeInstruction(operationRegister, vmDt, reg1=incReg)
+                code += VmCodeInstruction(Opcode.STOREX, vmDt, reg1=incReg, reg2=indexReg, value=variableAddr)
            }
        } else
            throw AssemblyError("weird assigntarget")
@@ -453,24 +724,24 @@ class CodeGen(internal val program: PtProgram,
    }

    private fun translate(repeat: PtRepeatLoop): VmCodeChunk {
-        if((repeat.count as? PtNumber)?.number==0.0)
-            return VmCodeChunk()
-        if((repeat.count as? PtNumber)?.number==1.0)
-            return translateGroup(repeat.children)
-        if((repeat.count as? PtNumber)?.number==256.0) {
-            // 256 iterations can still be done with just a byte counter if you set it to zero as starting value.
-            repeat.children[0] = PtNumber(DataType.UBYTE, 0.0, repeat.count.position)
+        when (constIntValue(repeat.count)) {
+            0 -> return VmCodeChunk()
+            1 -> return translateGroup(repeat.children)
+            256 -> {
+                // 256 iterations can still be done with just a byte counter if you set it to zero as starting value.
+                repeat.children[0] = PtNumber(DataType.UBYTE, 0.0, repeat.count.position)
+            }
        }

        val code = VmCodeChunk()
        val counterReg = vmRegisters.nextFree()
        val vmDt = vmType(repeat.count.type)
-        code += expressionEval.translateExpression(repeat.count, counterReg)
+        code += expressionEval.translateExpression(repeat.count, counterReg, -1)
        val repeatLabel = createLabelName()
        code += VmCodeLabel(repeatLabel)
        code += translateNode(repeat.statements)
        code += VmCodeInstruction(Opcode.DEC, vmDt, reg1=counterReg)
-        code += VmCodeInstruction(Opcode.BNZ, vmDt, reg1=counterReg, symbol = repeatLabel)
+        code += VmCodeInstruction(Opcode.BNZ, vmDt, reg1=counterReg, labelSymbol = repeatLabel)
        return code
    }

@@ -479,9 +750,9 @@ class CodeGen(internal val program: PtProgram,
        if(jump.address!=null)
            throw AssemblyError("cannot jump to memory location in the vm target")
        code += if(jump.generatedLabel!=null)
-            VmCodeInstruction(Opcode.JUMP, symbol = listOf(jump.generatedLabel!!))
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = listOf(jump.generatedLabel!!))
        else if(jump.identifier!=null)
-            VmCodeInstruction(Opcode.JUMP, symbol = jump.identifier!!.targetName)
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = jump.identifier!!.targetName)
        else
            throw AssemblyError("weird jump")
        return code
@@ -493,62 +764,21 @@ class CodeGen(internal val program: PtProgram,
        return code
    }

-    private fun translate(assignment: PtAssignment): VmCodeChunk {
-        // TODO can in-place assignments (assignment.augmentable = true) be optimized more?
-
-        val code = VmCodeChunk()
-        val resultRegister = vmRegisters.nextFree()
-        code += expressionEval.translateExpression(assignment.value, resultRegister)
-        val ident = assignment.target.identifier
-        val memory = assignment.target.memory
-        val array = assignment.target.array
-        val vmDt = vmType(assignment.value.type)
-        if(ident!=null) {
-            val address = allocations.get(ident.targetName)
-            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=address)
-        }
-        else if(array!=null) {
-            val variable = array.variable.targetName
-            var variableAddr = allocations.get(variable)
-            val itemsize = program.memsizer.memorySize(array.type)
-            val fixedIndex = (array.index as? PtNumber)?.number?.toInt()
-            val vmDtArrayIdx = vmType(array.type)
-            if(fixedIndex!=null) {
-                variableAddr += fixedIndex*itemsize
-                code += VmCodeInstruction(Opcode.STOREM, vmDtArrayIdx, reg1 = resultRegister, value=variableAddr)
-            } else {
-                val indexReg = vmRegisters.nextFree()
-                code += expressionEval.translateExpression(array.index, indexReg)
-                code += VmCodeInstruction(Opcode.STOREX, vmDtArrayIdx, reg1 = resultRegister, reg2=indexReg, value=variableAddr)
-            }
-        }
-        else if(memory!=null) {
-            if(memory.address is PtNumber) {
-                code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=resultRegister, value=(memory.address as PtNumber).number.toInt())
-            } else {
-                val addressRegister = vmRegisters.nextFree()
-                code += expressionEval.translateExpression(assignment.value, addressRegister)
-                code += VmCodeInstruction(Opcode.STOREI, vmDt, reg1=resultRegister, reg2=addressRegister)
-            }
-        }
-        else
-            throw AssemblyError("weird assigntarget")
-        return code
-    }
-
    private fun translate(ret: PtReturn): VmCodeChunk {
        val code = VmCodeChunk()
        val value = ret.value
        if(value!=null) {
-            // Call Convention: return value is always returned in r0
-            code += expressionEval.translateExpression(value, 0)
+            // Call Convention: return value is always returned in r0 (or fr0 if float)
+            code += if(value.type==DataType.FLOAT)
+                expressionEval.translateExpression(value, -1, 0)
+            else
+                expressionEval.translateExpression(value, 0, -1)
        }
        code += VmCodeInstruction(Opcode.RETURN)
        return code
    }

    private fun translate(sub: PtSub): VmCodeChunk {
-        // TODO actually inline subroutines marked as inline
        val code = VmCodeChunk()
        code += VmCodeComment("SUB: ${sub.scopedName} -> ${sub.returntype}")
        code += VmCodeLabel(sub.scopedName)
@@ -573,10 +803,12 @@ class CodeGen(internal val program: PtProgram,

    internal fun vmType(type: DataType): VmDataType {
        return when(type) {
+            DataType.BOOL,
            DataType.UBYTE,
            DataType.BYTE -> VmDataType.BYTE
            DataType.UWORD,
            DataType.WORD -> VmDataType.WORD
+            DataType.FLOAT -> VmDataType.FLOAT
            in PassByReferenceDatatypes -> VmDataType.WORD
            else -> throw AssemblyError("no vm datatype for $type")
        }
@@ -590,4 +822,9 @@ class CodeGen(internal val program: PtProgram,

    internal fun translateBuiltinFunc(call: PtBuiltinFunctionCall, resultRegister: Int): VmCodeChunk =
        builtinFuncGen.translate(call, resultRegister)
+
+    internal fun isZero(expression: PtExpression): Boolean = expression is PtNumber && expression.number==0.0
+
+    internal fun isOne(expression: PtExpression): Boolean = expression is PtNumber && expression.number==1.0
 }
+
@@ -3,51 +3,66 @@ package prog8.codegen.virtual
 import prog8.code.StStaticVariable
 import prog8.code.StSub
 import prog8.code.ast.*
-import prog8.code.core.AssemblyError
-import prog8.code.core.DataType
-import prog8.code.core.PassByValueDatatypes
-import prog8.code.core.SignedDatatypes
+import prog8.code.core.*
 import prog8.vm.Opcode
 import prog8.vm.VmDataType


 internal class ExpressionGen(private val codeGen: CodeGen) {
-    fun translateExpression(expr: PtExpression, resultRegister: Int): VmCodeChunk {
+    fun translateExpression(expr: PtExpression, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
        require(codeGen.vmRegisters.peekNext() > resultRegister)

        val code = VmCodeChunk()
-        val vmDt = codeGen.vmType(expr.type)

        when (expr) {
+            is PtMachineRegister -> {
+                if(resultRegister!=expr.register) {
+                    val vmDt = codeGen.vmType(expr.type)
+                    code += VmCodeInstruction(Opcode.LOADR, vmDt, reg1=resultRegister, reg2=expr.register)
+                }
+            }
            is PtNumber -> {
-                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=expr.number.toInt())
+                val vmDt = codeGen.vmType(expr.type)
+                code += if(vmDt==VmDataType.FLOAT)
+                    VmCodeInstruction(Opcode.LOAD, vmDt, fpReg1 = resultFpRegister, fpValue = expr.number.toFloat())
+                else
+                    VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=expr.number.toInt())
            }
            is PtIdentifier -> {
+                val vmDt = codeGen.vmType(expr.type)
                val mem = codeGen.allocations.get(expr.targetName)
-                code += if(expr.type in PassByValueDatatypes) {
-                    VmCodeInstruction(Opcode.LOADM, vmDt, reg1=resultRegister, value=mem)
+                code += if (expr.type in PassByValueDatatypes) {
+                    if(vmDt==VmDataType.FLOAT)
+                        VmCodeInstruction(Opcode.LOADM, vmDt, fpReg1 = resultFpRegister, value = mem)
+                    else
+                        VmCodeInstruction(Opcode.LOADM, vmDt, reg1 = resultRegister, value = mem)
                } else {
                    // for strings and arrays etc., load the *address* of the value instead
-                    VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=mem)
+                    VmCodeInstruction(Opcode.LOAD, vmDt, reg1 = resultRegister, value = mem)
                }
            }
            is PtAddressOf -> {
+                val vmDt = codeGen.vmType(expr.type)
                val mem = codeGen.allocations.get(expr.identifier.targetName)
                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=mem)
            }
            is PtMemoryByte -> {
-                val addressRegister = codeGen.vmRegisters.nextFree()
-                val addressExprCode = translateExpression(expr.address, addressRegister)
-                code += addressExprCode
+                if(expr.address is PtNumber) {
+                    val address = (expr.address as PtNumber).number.toInt()
+                    code += VmCodeInstruction(Opcode.LOADM, VmDataType.BYTE, reg1=resultRegister, value = address)
+                } else {
+                    val addressRegister = codeGen.vmRegisters.nextFree()
+                    code += translateExpression(expr.address, addressRegister, -1)
+                    code += VmCodeInstruction(Opcode.LOADI, VmDataType.BYTE, reg1=resultRegister, reg2=addressRegister)
+                }
            }
-            is PtTypeCast -> code += translate(expr, resultRegister)
+            is PtTypeCast -> code += translate(expr, resultRegister, resultFpRegister)
            is PtPrefix -> code += translate(expr, resultRegister)
-            is PtArrayIndexer -> code += translate(expr, resultRegister)
-            is PtBinaryExpression -> code += translate(expr, resultRegister)
+            is PtArrayIndexer -> code += translate(expr, resultRegister, resultFpRegister)
+            is PtBinaryExpression -> code += translate(expr, resultRegister, resultFpRegister)
            is PtBuiltinFunctionCall -> code += codeGen.translateBuiltinFunc(expr, resultRegister)
-            is PtFunctionCall -> code += translate(expr, resultRegister)
-            is PtContainmentCheck -> code += translate(expr, resultRegister)
-            is PtPipe -> code += translate(expr, resultRegister)
+            is PtFunctionCall -> code += translate(expr, resultRegister, resultFpRegister)
+            is PtContainmentCheck -> code += translate(expr, resultRegister, resultFpRegister)
            is PtRange,
            is PtArray,
            is PtString -> throw AssemblyError("range/arrayliteral/string should no longer occur as expression")
@@ -56,61 +71,77 @@ internal class ExpressionGen(private val codeGen: CodeGen) {
        return code
    }

-    internal fun translate(pipe: PtPipe, resultRegister: Int): VmCodeChunk {
-        TODO("Not yet implemented: pipe expression")
-    }
-
-    private fun translate(check: PtContainmentCheck, resultRegister: Int): VmCodeChunk {
+    private fun translate(check: PtContainmentCheck, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
        val code = VmCodeChunk()
-        code += translateExpression(check.element, resultRegister)   // load the element to check in resultRegister
+        code += translateExpression(check.element, resultRegister, -1)   // load the element to check in resultRegister
        val iterable = codeGen.symbolTable.flat.getValue(check.iterable.targetName) as StStaticVariable
        when(iterable.dt) {
            DataType.STR -> {
                val call = PtFunctionCall(listOf("prog8_lib", "string_contains"), false, DataType.UBYTE, check.position)
                call.children.add(check.element)
                call.children.add(check.iterable)
-                code += translate(call, resultRegister)
+                code += translate(call, resultRegister, resultFpRegister)
            }
            DataType.ARRAY_UB, DataType.ARRAY_B -> {
                val call = PtFunctionCall(listOf("prog8_lib", "bytearray_contains"), false, DataType.UBYTE, check.position)
                call.children.add(check.element)
                call.children.add(check.iterable)
                call.children.add(PtNumber(DataType.UBYTE, iterable.length!!.toDouble(), iterable.position))
-                code += translate(call, resultRegister)
+                code += translate(call, resultRegister, resultFpRegister)
            }
            DataType.ARRAY_UW, DataType.ARRAY_W -> {
                val call = PtFunctionCall(listOf("prog8_lib", "wordarray_contains"), false, DataType.UBYTE, check.position)
                call.children.add(check.element)
                call.children.add(check.iterable)
                call.children.add(PtNumber(DataType.UBYTE, iterable.length!!.toDouble(), iterable.position))
-                code += translate(call, resultRegister)
+                code += translate(call, resultRegister, resultFpRegister)
            }
-            DataType.ARRAY_F -> TODO("containment check in float-array")
+            DataType.ARRAY_F -> throw AssemblyError("containment check in float-array not supported")
            else -> throw AssemblyError("weird iterable dt ${iterable.dt} for ${check.iterable.targetName}")
        }
        return code
    }

-    private fun translate(arrayIx: PtArrayIndexer, resultRegister: Int): VmCodeChunk {
+    private fun translate(arrayIx: PtArrayIndexer, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
        val eltSize = codeGen.program.memsizer.memorySize(arrayIx.type)
        val vmDt = codeGen.vmType(arrayIx.type)
        val code = VmCodeChunk()
        val idxReg = codeGen.vmRegisters.nextFree()
-        // TODO: optimized code when the index is a constant value
-        code += translateExpression(arrayIx.index, idxReg)
-        if(eltSize>1) {
-            val factorReg = codeGen.vmRegisters.nextFree()
-            code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=factorReg, value=eltSize)
-            code += VmCodeInstruction(Opcode.MUL, VmDataType.BYTE, reg1=idxReg, reg2=idxReg, reg3=factorReg)
-        }
        val arrayLocation = codeGen.allocations.get(arrayIx.variable.targetName)
-        code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=resultRegister, reg2=idxReg, value = arrayLocation)
+
+        if(arrayIx.variable.type==DataType.UWORD) {
+            // indexing a pointer var instead of a real array or string
+            if(eltSize!=1)
+                throw AssemblyError("non-array var indexing requires bytes dt")
+            if(arrayIx.index.type!=DataType.UBYTE)
+                throw AssemblyError("non-array var indexing requires bytes index")
+            code += translateExpression(arrayIx.index, idxReg, -1)
+            code += VmCodeInstruction(Opcode.LOADIX, vmDt, reg1=resultRegister, reg2=idxReg, value = arrayLocation)
+            return code
+        }
+
+        if(arrayIx.index is PtNumber) {
+            // optimized code when index is known - just calculate the memory address here
+            val memOffset = (arrayIx.index as PtNumber).number.toInt() * eltSize
+            if(vmDt==VmDataType.FLOAT)
+                code += VmCodeInstruction(Opcode.LOADM, VmDataType.FLOAT, fpReg1=resultFpRegister, value=arrayLocation+memOffset)
+            else
+                code += VmCodeInstruction(Opcode.LOADM, vmDt, reg1=resultRegister, value=arrayLocation+memOffset)
+        } else {
+            code += translateExpression(arrayIx.index, idxReg, -1)
+            if(eltSize>1)
+                code += codeGen.multiplyByConst(VmDataType.BYTE, idxReg, eltSize)
+            if(vmDt==VmDataType.FLOAT)
+                code += VmCodeInstruction(Opcode.LOADX, VmDataType.FLOAT, fpReg1 = resultFpRegister, reg1=idxReg, value = arrayLocation)
+            else
+                code += VmCodeInstruction(Opcode.LOADX, vmDt, reg1=resultRegister, reg2=idxReg, value = arrayLocation)
+        }
        return code
    }

    private fun translate(expr: PtPrefix, resultRegister: Int): VmCodeChunk {
        val code = VmCodeChunk()
-        code += translateExpression(expr.value, resultRegister)
+        code += translateExpression(expr.value, resultRegister, -1)
        val vmDt = codeGen.vmType(expr.type)
        when(expr.operator) {
            "+" -> { }
@@ -118,46 +149,38 @@ internal class ExpressionGen(private val codeGen: CodeGen) {
                code += VmCodeInstruction(Opcode.NEG, vmDt, reg1=resultRegister)
            }
            "~" -> {
-                val regMask = codeGen.vmRegisters.nextFree()
                val mask = if(vmDt==VmDataType.BYTE) 0x00ff else 0xffff
-                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=regMask, value=mask)
-                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=resultRegister, reg3=regMask)
-            }
-            "not" -> {
-                val label = codeGen.createLabelName()
-                code += VmCodeInstruction(Opcode.BZ, vmDt, reg1=resultRegister, symbol = label)
-                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=resultRegister, value=1)
-                code += VmCodeLabel(label)
-                val regMask = codeGen.vmRegisters.nextFree()
-                code += VmCodeInstruction(Opcode.LOAD, vmDt, reg1=regMask, value=1)
-                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=resultRegister, reg3=regMask)
+                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, value=mask)
            }
            else -> throw AssemblyError("weird prefix operator")
        }
        return code
    }

-    private fun translate(cast: PtTypeCast, resultRegister: Int): VmCodeChunk {
+    private fun translate(cast: PtTypeCast, predefinedResultRegister: Int, predefinedResultFpRegister: Int): VmCodeChunk {
        val code = VmCodeChunk()
        if(cast.type==cast.value.type)
            return code
-        code += translateExpression(cast.value, resultRegister)
+        val actualResultFpReg = if(predefinedResultFpRegister>=0) predefinedResultFpRegister else codeGen.vmRegisters.nextFreeFloat()
+        val actualResultReg = if(predefinedResultRegister>=0) predefinedResultRegister else codeGen.vmRegisters.nextFree()
+        if(cast.value.type==DataType.FLOAT) {
+            // a cast from float to integer, so evaluate the value into a float register first
+            code += translateExpression(cast.value, -1, actualResultFpReg)
+        }
+        else
+            code += translateExpression(cast.value, actualResultReg, -1)
        when(cast.type) {
            DataType.UBYTE -> {
                when(cast.value.type) {
                    DataType.BYTE, DataType.UWORD, DataType.WORD -> { /* just keep the LSB as it is */ }
-                    DataType.FLOAT -> {
-                        TODO("float -> ubyte") // float not yet supported
-                    }
+                    DataType.FLOAT -> code += VmCodeInstruction(Opcode.FTOUB, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
                    else -> throw AssemblyError("weird cast value type")
                }
            }
            DataType.BYTE -> {
                when(cast.value.type) {
                    DataType.UBYTE, DataType.UWORD, DataType.WORD -> { /* just keep the LSB as it is */ }
-                    DataType.FLOAT -> {
-                        TODO("float -> byte") // float not yet supported
-                    }
+                    DataType.FLOAT -> code += VmCodeInstruction(Opcode.FTOSB, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
                    else -> throw AssemblyError("weird cast value type")
                }
            }
@@ -165,15 +188,15 @@ internal class ExpressionGen(private val codeGen: CodeGen) {
                when(cast.value.type) {
                    DataType.BYTE -> {
                        // byte -> uword:   sign extend
-                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = resultRegister)
+                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = actualResultReg)
                    }
                    DataType.UBYTE -> {
                        // ubyte -> uword:   sign extend
-                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = resultRegister)
+                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = actualResultReg)
                    }
                    DataType.WORD -> { }
                    DataType.FLOAT -> {
-                        TODO("float -> uword") // float not yet supported
+                        code += VmCodeInstruction(Opcode.FTOUW, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
                    }
                    else -> throw AssemblyError("weird cast value type")
                }
@@ -182,123 +205,650 @@ internal class ExpressionGen(private val codeGen: CodeGen) {
                when(cast.value.type) {
                    DataType.BYTE -> {
                        // byte -> word:   sign extend
-                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = resultRegister)
+                        code += VmCodeInstruction(Opcode.EXTS, type = VmDataType.BYTE, reg1 = actualResultReg)
                    }
                    DataType.UBYTE -> {
                        // byte -> word:   sign extend
-                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = resultRegister)
+                        code += VmCodeInstruction(Opcode.EXT, type = VmDataType.BYTE, reg1 = actualResultReg)
                    }
                    DataType.UWORD -> { }
                    DataType.FLOAT -> {
-                        TODO("float -> word") // float not yet supported
+                        code += VmCodeInstruction(Opcode.FTOSW, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
                    }
                    else -> throw AssemblyError("weird cast value type")
                }
            }
            DataType.FLOAT -> {
-                TODO("floating point not yet supported")
-//                when(cast.value.type) {
-//                    DataType.BYTE -> {
-//                    }
-//                    DataType.UBYTE -> {
-//                    }
-//                    DataType.WORD -> {
-//                    }
-//                    DataType.UWORD -> {
-//                    }
-//                    else -> throw AssemblyError("weird cast value type")
-//                }
+                code += when(cast.value.type) {
+                    DataType.UBYTE -> {
+                        VmCodeInstruction(Opcode.FFROMUB, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
+                    }
+                    DataType.BYTE -> {
+                        VmCodeInstruction(Opcode.FFROMSB, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
+                    }
+                    DataType.UWORD -> {
+                        VmCodeInstruction(Opcode.FFROMUW, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
+                    }
+                    DataType.WORD -> {
+                        VmCodeInstruction(Opcode.FFROMSW, VmDataType.FLOAT, reg1=actualResultReg, fpReg1 = actualResultFpReg)
+                    }
+                    else -> throw AssemblyError("weird cast value type")
+                }
            }
            else -> throw AssemblyError("weird cast type")
        }
        return code
    }

-    private fun translate(binExpr: PtBinaryExpression, resultRegister: Int): VmCodeChunk {
-        val code = VmCodeChunk()
-        val leftResultReg = codeGen.vmRegisters.nextFree()
-        val rightResultReg = codeGen.vmRegisters.nextFree()
-        // TODO: optimized codegen when left or right operand is known 0 or 1 or whatever. But only if this would result in a different opcode such as ADD 1 -> INC, MUL 1 -> NOP
-        //       actually optimizing the code should not be done here but in a tailored code optimizer step.
-        val leftCode = translateExpression(binExpr.left, leftResultReg)
-        val rightCode = translateExpression(binExpr.right, rightResultReg)
-        code += leftCode
-        code += rightCode
+    private fun translate(binExpr: PtBinaryExpression, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
        val vmDt = codeGen.vmType(binExpr.left.type)
        val signed = binExpr.left.type in SignedDatatypes
-        when(binExpr.operator) {
-            "+" -> {
-                code += VmCodeInstruction(Opcode.ADD, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "-" -> {
-                code += VmCodeInstruction(Opcode.SUB, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "*" -> {
-                code += VmCodeInstruction(Opcode.MUL, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "/" -> {
-                code += VmCodeInstruction(Opcode.DIV, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "%" -> {
-                code += VmCodeInstruction(Opcode.MOD, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "|", "or" -> {
-                code += VmCodeInstruction(Opcode.OR, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "&", "and" -> {
-                code += VmCodeInstruction(Opcode.AND, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "^", "xor" -> {
-                code += VmCodeInstruction(Opcode.XOR, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "<<" -> {
-                code += VmCodeInstruction(Opcode.LSL, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            ">>" -> {
-                val opc = if(signed) Opcode.ASR else Opcode.LSR
-                code += VmCodeInstruction(opc, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "==" -> {
-                code += VmCodeInstruction(Opcode.SEQ, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "!=" -> {
-                code += VmCodeInstruction(Opcode.SNE, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "<" -> {
-                val ins = if(signed) Opcode.SLTS else Opcode.SLT
-                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            ">" -> {
-                val ins = if(signed) Opcode.SGTS else Opcode.SGT
-                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            "<=" -> {
-                val ins = if(signed) Opcode.SLES else Opcode.SLE
-                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
-            ">=" -> {
-                val ins = if(signed) Opcode.SGES else Opcode.SGE
-                code += VmCodeInstruction(ins, vmDt, reg1=resultRegister, reg2=leftResultReg, reg3=rightResultReg)
-            }
+        return when(binExpr.operator) {
+            "+" -> operatorPlus(binExpr, vmDt, resultRegister, resultFpRegister)
+            "-" -> operatorMinus(binExpr, vmDt, resultRegister, resultFpRegister)
+            "*" -> operatorMultiply(binExpr, vmDt, resultRegister, resultFpRegister)
+            "/" -> operatorDivide(binExpr, vmDt, resultRegister, resultFpRegister, signed)
+            "%" -> operatorModulo(binExpr, vmDt, resultRegister)
+            "|" -> operatorOr(binExpr, vmDt, resultRegister)
+            "&" -> operatorAnd(binExpr, vmDt, resultRegister)
+            "^" -> operatorXor(binExpr, vmDt, resultRegister)
+            "<<" -> operatorShiftLeft(binExpr, vmDt, resultRegister)
+            ">>" -> operatorShiftRight(binExpr, vmDt, resultRegister, signed)
+            "==" -> operatorEquals(binExpr, vmDt, resultRegister, false)
+            "!=" -> operatorEquals(binExpr, vmDt, resultRegister, true)
+            "<" -> operatorLessThan(binExpr, vmDt, resultRegister, signed, false)
+            ">" -> operatorGreaterThan(binExpr, vmDt, resultRegister, signed, false)
+            "<=" -> operatorLessThan(binExpr, vmDt, resultRegister, signed, true)
+            ">=" -> operatorGreaterThan(binExpr, vmDt, resultRegister, signed, true)
            else -> throw AssemblyError("weird operator ${binExpr.operator}")
        }
+    }
+
+    private fun operatorGreaterThan(
+        binExpr: PtBinaryExpression,
+        vmDt: VmDataType,
+        resultRegister: Int,
+        signed: Boolean,
+        greaterEquals: Boolean
+    ): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            val leftFpReg = codeGen.vmRegisters.nextFreeFloat()
+            val rightFpReg = codeGen.vmRegisters.nextFreeFloat()
+            val zeroRegister = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, -1, leftFpReg)
+            code += translateExpression(binExpr.right, -1, rightFpReg)
+            code += VmCodeInstruction(Opcode.FCOMP, VmDataType.FLOAT, reg1=resultRegister, fpReg1 = leftFpReg, fpReg2 = rightFpReg)
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=zeroRegister, value=0)
+            val ins = if (signed) {
+                if (greaterEquals) Opcode.SGES else Opcode.SGTS
+            } else {
+                if (greaterEquals) Opcode.SGE else Opcode.SGT
+            }
+            code += VmCodeInstruction(ins, VmDataType.BYTE, reg1 = resultRegister, reg2 = zeroRegister)
+        } else {
+            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+                val comparisonCall = PtFunctionCall(listOf("prog8_lib", "string_compare"), false, DataType.BYTE, Position.DUMMY)
+                comparisonCall.children.add(binExpr.left)
+                comparisonCall.children.add(binExpr.right)
+                code += translate(comparisonCall, resultRegister, -1)
+                val zeroRegister = codeGen.vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=zeroRegister, value=0)
+                code += if(greaterEquals)
+                    VmCodeInstruction(Opcode.SGES, VmDataType.BYTE, reg1=resultRegister, reg2=zeroRegister)
+                else
+                    VmCodeInstruction(Opcode.SGTS, VmDataType.BYTE, reg1=resultRegister, reg2=zeroRegister)
+            } else {
+                val rightResultReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += translateExpression(binExpr.right, rightResultReg, -1)
+                val ins = if (signed) {
+                    if (greaterEquals) Opcode.SGES else Opcode.SGTS
+                } else {
+                    if (greaterEquals) Opcode.SGE else Opcode.SGT
+                }
+                code += VmCodeInstruction(ins, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+            }
+        }
        return code
    }

-    fun translate(fcall: PtFunctionCall, resultRegister: Int): VmCodeChunk {
+    private fun operatorLessThan(
+        binExpr: PtBinaryExpression,
+        vmDt: VmDataType,
+        resultRegister: Int,
+        signed: Boolean,
+        lessEquals: Boolean
+    ): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            val leftFpReg = codeGen.vmRegisters.nextFreeFloat()
+            val rightFpReg = codeGen.vmRegisters.nextFreeFloat()
+            val zeroRegister = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, -1, leftFpReg)
+            code += translateExpression(binExpr.right, -1, rightFpReg)
+            code += VmCodeInstruction(Opcode.FCOMP, VmDataType.FLOAT, reg1=resultRegister, fpReg1 = leftFpReg, fpReg2 = rightFpReg)
+            code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=zeroRegister, value=0)
+            val ins = if (signed) {
+                if (lessEquals) Opcode.SLES else Opcode.SLTS
+            } else {
+                if (lessEquals) Opcode.SLE else Opcode.SLT
+            }
+            code += VmCodeInstruction(ins, VmDataType.BYTE, reg1 = resultRegister, reg2 = zeroRegister)
+        } else {
+            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+                val comparisonCall = PtFunctionCall(listOf("prog8_lib", "string_compare"), false, DataType.BYTE, Position.DUMMY)
+                comparisonCall.children.add(binExpr.left)
+                comparisonCall.children.add(binExpr.right)
+                code += translate(comparisonCall, resultRegister, -1)
+                val zeroRegister = codeGen.vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=zeroRegister, value=0)
+                code += if(lessEquals)
+                    VmCodeInstruction(Opcode.SLES, VmDataType.BYTE, reg1=resultRegister, reg2=zeroRegister)
+                else
+                    VmCodeInstruction(Opcode.SLTS, VmDataType.BYTE, reg1=resultRegister, reg2=zeroRegister)
+            } else {
+                val rightResultReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += translateExpression(binExpr.right, rightResultReg, -1)
+                val ins = if (signed) {
+                    if (lessEquals) Opcode.SLES else Opcode.SLTS
+                } else {
+                    if (lessEquals) Opcode.SLE else Opcode.SLT
+                }
+                code += VmCodeInstruction(ins, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+            }
+        }
+        return code
+    }
+
+    private fun operatorEquals(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int, notEquals: Boolean): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            val leftFpReg = codeGen.vmRegisters.nextFreeFloat()
+            val rightFpReg = codeGen.vmRegisters.nextFreeFloat()
+            code += translateExpression(binExpr.left, -1, leftFpReg)
+            code += translateExpression(binExpr.right, -1, rightFpReg)
+            if (notEquals) {
+                code += VmCodeInstruction(Opcode.FCOMP, VmDataType.FLOAT, reg1=resultRegister, fpReg1 = leftFpReg, fpReg2 = rightFpReg)
+            } else {
+                val label = codeGen.createLabelName()
+                val valueReg = codeGen.vmRegisters.nextFree()
+                code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=resultRegister, value=1)
+                code += VmCodeInstruction(Opcode.FCOMP, VmDataType.FLOAT, reg1=valueReg, fpReg1 = leftFpReg, fpReg2 = rightFpReg)
+                code += VmCodeInstruction(Opcode.BZ, VmDataType.BYTE, reg1=valueReg, labelSymbol = label)
+                code += VmCodeInstruction(Opcode.LOAD, VmDataType.BYTE, reg1=resultRegister, value=0)
+                code += VmCodeLabel(label)
+            }
+        } else {
+            if(binExpr.left.type==DataType.STR && binExpr.right.type==DataType.STR) {
+                val comparisonCall = PtFunctionCall(listOf("prog8_lib", "string_compare"), false, DataType.BYTE, Position.DUMMY)
+                comparisonCall.children.add(binExpr.left)
+                comparisonCall.children.add(binExpr.right)
+                code += translate(comparisonCall, resultRegister, -1)
+                if(!notEquals)
+                    code += VmCodeInstruction(Opcode.INV, vmDt, reg1=resultRegister)
+                code += VmCodeInstruction(Opcode.AND, vmDt, reg1=resultRegister, value=1)
+            } else {
+                val rightResultReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += translateExpression(binExpr.right, rightResultReg, -1)
+                val opcode = if (notEquals) Opcode.SNE else Opcode.SEQ
+                code += VmCodeInstruction(opcode, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+            }
+        }
+        return code
+    }
+
+    private fun operatorShiftRight(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int, signed: Boolean): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isOne(binExpr.right)) {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            val opc = if (signed) Opcode.ASR else Opcode.LSR
+            code += VmCodeInstruction(opc, vmDt, reg1 = resultRegister)
+        } else {
+            val rightResultReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            val opc = if (signed) Opcode.ASRN else Opcode.LSRN
+            code += VmCodeInstruction(opc, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+        }
+        return code
+    }
+
+    internal fun operatorShiftRightInplace(address: Int, vmDt: VmDataType,  signed: Boolean, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isOne(operand)) {
+            val opc = if (signed) Opcode.ASRM else Opcode.LSRM
+            code += VmCodeInstruction(opc, vmDt, value=address)
+        } else {
+            val operandReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(operand, operandReg, -1)
+            val opc = if (signed) Opcode.ASRNM else Opcode.LSRNM
+            code += VmCodeInstruction(opc, vmDt, reg1 = operandReg, value=address)
+        }
+        return code
+    }
+
+    private fun operatorShiftLeft(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isOne(binExpr.right)){
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += VmCodeInstruction(Opcode.LSL, vmDt, reg1=resultRegister)
+        } else {
+            val rightResultReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            code += VmCodeInstruction(Opcode.LSLN, vmDt, reg1=resultRegister, rightResultReg)
+        }
+        return code
+    }
+
+    internal fun operatorShiftLeftInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(codeGen.isOne(operand)){
+            code += VmCodeInstruction(Opcode.LSLM, vmDt, value=address)
+        } else {
+            val operandReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(operand, operandReg, -1)
+            code += VmCodeInstruction(Opcode.LSLNM, vmDt, reg1=operandReg, value=address)
+        }
+        return code
+    }
+
+    private fun operatorXor(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(binExpr.right is PtNumber) {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += VmCodeInstruction(Opcode.XOR, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+        } else {
+            val rightResultReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            code += VmCodeInstruction(Opcode.XORR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+        }
+        return code
+    }
+
+    internal fun operatorXorInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        val operandReg = codeGen.vmRegisters.nextFree()
+        code += translateExpression(operand, operandReg, -1)
+        code += VmCodeInstruction(Opcode.XORM, vmDt, reg1=operandReg, value = address)
+        return code
+    }
+
+    private fun operatorAnd(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(binExpr.right is PtNumber) {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += VmCodeInstruction(Opcode.AND, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+        } else {
+            val rightResultReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            code += VmCodeInstruction(Opcode.ANDR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+        }
+        return code
+    }
+
+    internal  fun operatorAndInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        val operandReg = codeGen.vmRegisters.nextFree()
+        code += translateExpression(operand, operandReg, -1)
+        code += VmCodeInstruction(Opcode.ANDM, vmDt, reg1=operandReg, value=address)
+        return code
+    }
+
+    private fun operatorOr(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(binExpr.right is PtNumber) {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += VmCodeInstruction(Opcode.OR, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+        } else {
+            val rightResultReg = codeGen.vmRegisters.nextFree()
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            code += VmCodeInstruction(Opcode.ORR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+        }
+        return code
+    }
+
+    internal fun operatorOrInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        val operandReg = codeGen.vmRegisters.nextFree()
+        code += translateExpression(operand, operandReg, -1)
+        code += VmCodeInstruction(Opcode.ORM, vmDt, reg1=operandReg, value = address)
+        return code
+    }
+
+    private fun operatorModulo(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int): VmCodeChunk {
+        if(vmDt==VmDataType.FLOAT)
+            throw IllegalArgumentException("floating-point modulo not supported")
+        val code = VmCodeChunk()
+        val rightResultReg = codeGen.vmRegisters.nextFree()
+        if(binExpr.right is PtNumber) {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += VmCodeInstruction(Opcode.MOD, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+        } else {
+            code += translateExpression(binExpr.left, resultRegister, -1)
+            code += translateExpression(binExpr.right, rightResultReg, -1)
+            code += VmCodeInstruction(Opcode.MODR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+        }
+        return code
+    }
+
+    private fun operatorDivide(binExpr: PtBinaryExpression,
+                               vmDt: VmDataType,
+                               resultRegister: Int,
+                               resultFpRegister: Int,
+                               signed: Boolean): VmCodeChunk {
+        val code = VmCodeChunk()
+        val constFactorRight = binExpr.right as? PtNumber
+        if(vmDt==VmDataType.FLOAT) {
+            if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                val factor = constFactorRight.number.toFloat()
+                code += codeGen.divideByConstFloat(resultFpRegister, factor)
+            } else {
+                val rightResultFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                code += translateExpression(binExpr.right, -1, rightResultFpReg)
+                code += if(signed)
+                    VmCodeInstruction(Opcode.DIVSR, vmDt, fpReg1 = resultFpRegister, fpReg2=rightResultFpReg)
+                else
+                    VmCodeInstruction(Opcode.DIVR, vmDt, fpReg1 = resultFpRegister, fpReg2=rightResultFpReg)
+            }
+        } else {
+            if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                val factor = constFactorRight.number.toInt()
+                code += codeGen.divideByConst(vmDt, resultRegister, factor, signed)
+            } else {
+                val rightResultReg = codeGen.vmRegisters.nextFree()
+                if(binExpr.right is PtNumber) {
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += if (signed)
+                        VmCodeInstruction(Opcode.DIVS, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+                    else
+                        VmCodeInstruction(Opcode.DIV, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+                } else {
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += translateExpression(binExpr.right, rightResultReg, -1)
+                    code += if (signed)
+                        VmCodeInstruction(Opcode.DIVSR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+                    else
+                        VmCodeInstruction(Opcode.DIVR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+                }
+            }
+        }
+        return code
+    }
+
+    internal fun operatorDivideInplace(address: Int, vmDt: VmDataType, signed: Boolean, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        val constFactorRight = operand as? PtNumber
+        if(vmDt==VmDataType.FLOAT) {
+            if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                val factor = constFactorRight.number.toFloat()
+                code += codeGen.divideByConstFloatInplace(address, factor)
+            } else {
+                val operandFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(operand, -1, operandFpReg)
+                code += if(signed)
+                    VmCodeInstruction(Opcode.DIVSM, vmDt, fpReg1 = operandFpReg, value=address)
+                else
+                    VmCodeInstruction(Opcode.DIVM, vmDt, fpReg1 = operandFpReg, value=address)
+            }
+        } else {
+            if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                val factor = constFactorRight.number.toInt()
+                code += codeGen.divideByConstInplace(vmDt, address, factor, signed)
+            } else {
+                val operandReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(operand, operandReg, -1)
+                code += if(signed)
+                    VmCodeInstruction(Opcode.DIVSM, vmDt, reg1=operandReg, value = address)
+                else
+                    VmCodeInstruction(Opcode.DIVM, vmDt, reg1=operandReg, value = address)
+            }
+        }
+        return code
+    }
+
+    private fun operatorMultiply(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        val constFactorLeft = binExpr.left as? PtNumber
+        val constFactorRight = binExpr.right as? PtNumber
+        if(vmDt==VmDataType.FLOAT) {
+            if(constFactorLeft!=null) {
+                code += translateExpression(binExpr.right, -1, resultFpRegister)
+                val factor = constFactorLeft.number.toFloat()
+                code += codeGen.multiplyByConstFloat(resultFpRegister, factor)
+            } else if(constFactorRight!=null) {
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                val factor = constFactorRight.number.toFloat()
+                code += codeGen.multiplyByConstFloat(resultFpRegister, factor)
+            } else {
+                val rightResultFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                code += translateExpression(binExpr.right, -1, rightResultFpReg)
+                code += VmCodeInstruction(Opcode.MULR, vmDt, fpReg1 = resultFpRegister, fpReg2 = rightResultFpReg)
+            }
+        } else {
+            if(constFactorLeft!=null && constFactorLeft.type!=DataType.FLOAT) {
+                code += translateExpression(binExpr.right, resultRegister, -1)
+                val factor = constFactorLeft.number.toInt()
+                code += codeGen.multiplyByConst(vmDt, resultRegister, factor)
+            } else if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                val factor = constFactorRight.number.toInt()
+                code += codeGen.multiplyByConst(vmDt, resultRegister, factor)
+            } else {
+                val rightResultReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += translateExpression(binExpr.right, rightResultReg, -1)
+                code += VmCodeInstruction(Opcode.MULR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+            }
+        }
+        return code
+    }
+
+    internal fun operatorMultiplyInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        val constFactorRight = operand as? PtNumber
+        if(vmDt==VmDataType.FLOAT) {
+            if(constFactorRight!=null) {
+                val factor = constFactorRight.number.toFloat()
+                code += codeGen.multiplyByConstFloatInplace(address, factor)
+            } else {
+                val operandFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(operand, -1, operandFpReg)
+                code += VmCodeInstruction(Opcode.MULM, vmDt, fpReg1 = operandFpReg, value = address)
+            }
+        } else {
+            if(constFactorRight!=null && constFactorRight.type!=DataType.FLOAT) {
+                val factor = constFactorRight.number.toInt()
+                code += codeGen.multiplyByConstInplace(vmDt, address, factor)
+            } else {
+                val operandReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(operand, operandReg, -1)
+                code += VmCodeInstruction(Opcode.MULM, vmDt, reg1=operandReg, value = address)
+            }
+        }
+        return code
+    }
+
+    private fun operatorMinus(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            if((binExpr.right as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                code += VmCodeInstruction(Opcode.DEC, vmDt, fpReg1 = resultFpRegister)
+            }
+            else {
+                if(binExpr.right is PtNumber) {
+                    code += translateExpression(binExpr.left, -1, resultFpRegister)
+                    code += VmCodeInstruction(Opcode.SUB, vmDt, fpReg1 = resultFpRegister, fpValue = (binExpr.right as PtNumber).number.toFloat())
+                } else {
+                    val rightResultFpReg = codeGen.vmRegisters.nextFreeFloat()
+                    code += translateExpression(binExpr.left, -1, resultFpRegister)
+                    code += translateExpression(binExpr.right, -1, rightResultFpReg)
+                    code += VmCodeInstruction(Opcode.SUBR, vmDt, fpReg1 = resultFpRegister, fpReg2 = rightResultFpReg)
+                }
+            }
+        } else {
+            if((binExpr.right as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += VmCodeInstruction(Opcode.DEC, vmDt, reg1=resultRegister)
+            }
+            else {
+                if(binExpr.right is PtNumber) {
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += VmCodeInstruction(Opcode.SUB, vmDt, reg1 = resultRegister, value = (binExpr.right as PtNumber).number.toInt())
+                } else {
+                    val rightResultReg = codeGen.vmRegisters.nextFree()
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += translateExpression(binExpr.right, rightResultReg, -1)
+                    code += VmCodeInstruction(Opcode.SUBR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+                }
+            }
+        }
+        return code
+    }
+
+    internal fun operatorMinusInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            if((operand as? PtNumber)?.number==1.0) {
+                code += VmCodeInstruction(Opcode.DECM, vmDt, value=address)
+            }
+            else {
+                val operandFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(operand, -1, operandFpReg)
+                code += VmCodeInstruction(Opcode.SUBM, vmDt, fpReg1=operandFpReg, value=address)
+            }
+        } else {
+            if((operand as? PtNumber)?.number==1.0) {
+                code += VmCodeInstruction(Opcode.DECM, vmDt, value=address)
+            }
+            else {
+                val operandReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(operand, operandReg, -1)
+                code += VmCodeInstruction(Opcode.SUBM, vmDt, reg1=operandReg, value = address)
+            }
+        }
+        return code
+    }
+
+    private fun operatorPlus(binExpr: PtBinaryExpression, vmDt: VmDataType, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            if((binExpr.left as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.right, -1, resultFpRegister)
+                code += VmCodeInstruction(Opcode.INC, vmDt, fpReg1=resultFpRegister)
+            }
+            else if((binExpr.right as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.left, -1, resultFpRegister)
+                code += VmCodeInstruction(Opcode.INC, vmDt, fpReg1=resultFpRegister)
+            }
+            else {
+                if(binExpr.right is PtNumber) {
+                    code += translateExpression(binExpr.left, -1, resultFpRegister)
+                    code += VmCodeInstruction(Opcode.ADD, vmDt, fpReg1 = resultFpRegister, fpValue = (binExpr.right as PtNumber).number.toFloat())
+                } else {
+                    val rightResultFpReg = codeGen.vmRegisters.nextFreeFloat()
+                    code += translateExpression(binExpr.left, -1, resultFpRegister)
+                    code += translateExpression(binExpr.right, -1, rightResultFpReg)
+                    code += VmCodeInstruction(Opcode.ADDR, vmDt, fpReg1 = resultFpRegister, fpReg2 = rightResultFpReg)
+                }
+            }
+        } else {
+            if((binExpr.left as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.right, resultRegister, -1)
+                code += VmCodeInstruction(Opcode.INC, vmDt, reg1=resultRegister)
+            }
+            else if((binExpr.right as? PtNumber)?.number==1.0) {
+                code += translateExpression(binExpr.left, resultRegister, -1)
+                code += VmCodeInstruction(Opcode.INC, vmDt, reg1=resultRegister)
+            }
+            else {
+                if(binExpr.right is PtNumber) {
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += VmCodeInstruction(Opcode.ADD, vmDt, reg1 = resultRegister, value=(binExpr.right as PtNumber).number.toInt())
+                } else {
+                    val rightResultReg = codeGen.vmRegisters.nextFree()
+                    code += translateExpression(binExpr.left, resultRegister, -1)
+                    code += translateExpression(binExpr.right, rightResultReg, -1)
+                    code += VmCodeInstruction(Opcode.ADDR, vmDt, reg1 = resultRegister, reg2 = rightResultReg)
+                }
+            }
+        }
+        return code
+    }
+
+    internal fun operatorPlusInplace(address: Int, vmDt: VmDataType, operand: PtExpression): VmCodeChunk {
+        val code = VmCodeChunk()
+        if(vmDt==VmDataType.FLOAT) {
+            if((operand as? PtNumber)?.number==1.0) {
+                code += VmCodeInstruction(Opcode.INCM, vmDt, value = address)
+            }
+            else {
+                val operandFpReg = codeGen.vmRegisters.nextFreeFloat()
+                code += translateExpression(operand, -1, operandFpReg)
+                code += VmCodeInstruction(Opcode.ADDM, vmDt, fpReg1=operandFpReg, value=address)
+            }
+        } else {
+            if((operand as? PtNumber)?.number==1.0) {
+                code += VmCodeInstruction(Opcode.INCM, vmDt, value = address)
+            }
+            else {
+                val operandReg = codeGen.vmRegisters.nextFree()
+                code += translateExpression(operand, operandReg, -1)
+                code += VmCodeInstruction(Opcode.ADDM, vmDt, reg1=operandReg, value=address)
+            }
+        }
+        return code
+    }
+
+    fun translate(fcall: PtFunctionCall, resultRegister: Int, resultFpRegister: Int): VmCodeChunk {
        val subroutine = codeGen.symbolTable.flat.getValue(fcall.functionName) as StSub
        val code = VmCodeChunk()
        for ((arg, parameter) in fcall.args.zip(subroutine.parameters)) {
-            val argReg = codeGen.vmRegisters.nextFree()
-            code += translateExpression(arg, argReg)
-            val vmDt = codeGen.vmType(parameter.type)
-            val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
-            code += VmCodeInstruction(Opcode.STOREM, vmDt, reg1=argReg, value=mem)
+            val paramDt = codeGen.vmType(parameter.type)
+            if(codeGen.isZero(arg)) {
+                if (paramDt == VmDataType.FLOAT) {
+                    val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
+                    code += VmCodeInstruction(Opcode.STOREZM, paramDt, value = mem)
+                } else {
+                    val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
+                    code += VmCodeInstruction(Opcode.STOREZM, paramDt, value = mem)
+                }
+            } else {
+                if (paramDt == VmDataType.FLOAT) {
+                    val argFpReg = codeGen.vmRegisters.nextFreeFloat()
+                    code += translateExpression(arg, -1, argFpReg)
+                    val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
+                    code += VmCodeInstruction(Opcode.STOREM, paramDt, fpReg1 = argFpReg, value = mem)
+                } else {
+                    val argReg = codeGen.vmRegisters.nextFree()
+                    code += translateExpression(arg, argReg, -1)
+                    val mem = codeGen.allocations.get(fcall.functionName + parameter.name)
+                    code += VmCodeInstruction(Opcode.STOREM, paramDt, reg1 = argReg, value = mem)
+                }
+            }
        }
-        code += VmCodeInstruction(Opcode.CALL, symbol=fcall.functionName)
-        if(!fcall.void && resultRegister!=0) {
-            // Call convention: result value is in r0, so put it in the required register instead.
-            code += VmCodeInstruction(Opcode.LOADR, codeGen.vmType(fcall.type), reg1=resultRegister, reg2=0)
+        code += VmCodeInstruction(Opcode.CALL, labelSymbol=fcall.functionName)
+        if(fcall.type==DataType.FLOAT) {
+            if (!fcall.void && resultFpRegister != 0) {
+                // Call convention: result value is in fr0, so put it in the required register instead.
+                code += VmCodeInstruction(Opcode.LOADR, VmDataType.FLOAT, fpReg1 = resultFpRegister, fpReg2 = 0)
+            }
+        } else {
+            if (!fcall.void && resultRegister != 0) {
+                // Call convention: result value is in r0, so put it in the required register instead.
+                code += VmCodeInstruction(Opcode.LOADR, codeGen.vmType(fcall.type), reg1 = resultRegister, reg2 = 0)
+            }
        }
        return code
    }
@@ -4,7 +4,7 @@ import prog8.code.SymbolTable
 import prog8.code.ast.PtProgram
 import prog8.code.core.*

-class VariableAllocator(private val st: SymbolTable, private val program: PtProgram, errors: IErrorReporter) {
+class VariableAllocator(private val st: SymbolTable, private val program: PtProgram) {

    private val allocations = mutableMapOf<List<String>, Int>()
    private var freeMemoryStart: Int
@@ -26,6 +26,18 @@ class VariableAllocator(private val st: SymbolTable, private val program: PtProg
            allocations[variable.scopedName] = nextLocation
            nextLocation += memsize
        }
+        for (memvar in st.allMemMappedVariables) {
+            // TODO virtual machine doesn't have memory mapped variables, so treat them as regular allocated variables for now
+            val memsize =
+                when (memvar.dt) {
+                    in NumericDatatypes -> program.memsizer.memorySize(memvar.dt)
+                    in ArrayDatatypes -> program.memsizer.memorySize(memvar.dt, memvar.length!!)
+                    else -> throw InternalCompilerException("weird dt")
+                }
+
+            allocations[memvar.scopedName] = nextLocation
+            nextLocation += memsize
+        }

        freeMemoryStart = nextLocation
    }
@@ -67,7 +79,7 @@ class VariableAllocator(private val st: SymbolTable, private val program: PtProg
                }
                else -> throw InternalCompilerException("weird dt")
            }
-            mm.add(Pair(variable.scopedName, "${location.toHex()} $typeStr $value"))
+            mm.add(Pair(variable.scopedName, "$location $typeStr $value"))
        }
        return mm
    }
@@ -0,0 +1,189 @@
+package prog8.codegen.virtual
+
+import prog8.vm.Instruction
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+
+internal class VmOptimizerException(msg: String): Exception(msg)
+
+
+class VmPeepholeOptimizer(private val vmprog: AssemblyProgram, private val allocations: VariableAllocator) {
+    fun optimize() {
+        vmprog.getBlocks().forEach { block ->
+            do {
+                val indexedInstructions = block.lines.withIndex()
+                    .filter { it.value is VmCodeInstruction }
+                    .map { IndexedValue(it.index, (it.value as VmCodeInstruction).ins) }
+                val changed = removeNops(block, indexedInstructions)
+                        || removeDoubleLoadsAndStores(block, indexedInstructions)       // TODO not yet implemented
+                        || removeUselessArithmetic(block, indexedInstructions)
+                        || removeWeirdBranches(block, indexedInstructions)
+                        || removeDoubleSecClc(block, indexedInstructions)
+                        || cleanupPushPop(block, indexedInstructions)
+                // TODO other optimizations:
+                //  more complex optimizations such as unused registers
+            } while(changed)
+        }
+    }
+
+    private fun cleanupPushPop(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        //  push followed by pop to same target, or different target->replace with load
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(ins.opcode==Opcode.PUSH) {
+                if(idx < block.lines.size-1) {
+                    val insAfter = block.lines[idx+1] as? VmCodeInstruction
+                    if(insAfter!=null && insAfter.ins.opcode ==Opcode.POP) {
+                        if(ins.reg1==insAfter.ins.reg1) {
+                            block.lines.removeAt(idx)
+                            block.lines.removeAt(idx)
+                        } else {
+                            block.lines[idx] = VmCodeInstruction(Opcode.LOADR, ins.type, reg1=insAfter.ins.reg1, reg2=ins.reg1)
+                            block.lines.removeAt(idx+1)
+                        }
+                        changed = true
+                    }
+                }
+            }
+        }
+        return changed
+    }
+
+
+    private fun removeDoubleSecClc(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        //  double sec, clc
+        //  sec+clc or clc+sec
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(ins.opcode==Opcode.SEC || ins.opcode==Opcode.CLC) {
+                if(idx < block.lines.size-1) {
+                    val insAfter = block.lines[idx+1] as? VmCodeInstruction
+                    if(insAfter?.ins?.opcode == ins.opcode) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                    else if(ins.opcode==Opcode.SEC && insAfter?.ins?.opcode==Opcode.CLC) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                    else if(ins.opcode==Opcode.CLC && insAfter?.ins?.opcode==Opcode.SEC) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+            }
+        }
+        return changed
+    }
+
+    private fun removeWeirdBranches(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        //  jump/branch to label immediately below
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if(ins.opcode==Opcode.JUMP && ins.labelSymbol!=null) {
+                // if jumping to label immediately following this
+                if(idx < block.lines.size-1) {
+                    val label = block.lines[idx+1] as? VmCodeLabel
+                    if(label?.name == ins.labelSymbol) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+            }
+        }
+        return changed
+    }
+
+    private fun removeUselessArithmetic(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        // note: this is hard to solve for the non-immediate instructions atm because the values are loaded into registers first
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            when (ins.opcode) {
+                Opcode.DIV, Opcode.DIVS, Opcode.MUL, Opcode.MOD -> {
+                    if (ins.value == 1) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+                Opcode.ADD, Opcode.SUB -> {
+                    if (ins.value == 1) {
+                        block.lines[idx] = VmCodeInstruction(
+                            if (ins.opcode == Opcode.ADD) Opcode.INC else Opcode.DEC,
+                            ins.type,
+                            ins.reg1
+                        )
+                        changed = true
+                    } else if (ins.value == 0) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+                Opcode.AND -> {
+                    if (ins.value == 0) {
+                        block.lines[idx] = VmCodeInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, value = 0)
+                        changed = true
+                    } else if (ins.value == 255 && ins.type == VmDataType.BYTE) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    } else if (ins.value == 65535 && ins.type == VmDataType.WORD) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+                Opcode.OR -> {
+                    if (ins.value == 0) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    } else if ((ins.value == 255 && ins.type == VmDataType.BYTE) || (ins.value == 65535 && ins.type == VmDataType.WORD)) {
+                        block.lines[idx] = VmCodeInstruction(Opcode.LOAD, ins.type, reg1 = ins.reg1, value = ins.value)
+                        changed = true
+                    }
+                }
+                Opcode.XOR -> {
+                    if (ins.value == 0) {
+                        block.lines.removeAt(idx)
+                        changed = true
+                    }
+                }
+                else -> {}
+            }
+        }
+        return changed
+    }
+
+    private fun removeNops(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        var changed = false
+        indexedInstructions.reversed().forEach { (idx, ins) ->
+            if (ins.opcode == Opcode.NOP) {
+                changed = true
+                block.lines.removeAt(idx)
+            }
+        }
+        return changed
+    }
+
+    private fun removeDoubleLoadsAndStores(block: VmCodeChunk, indexedInstructions: List<IndexedValue<Instruction>>): Boolean {
+        var changed = false
+        indexedInstructions.forEach { (idx, ins) ->
+
+            // TODO: detect multiple loads to the same target registers, only keep first (if source is not I/O memory)
+            // TODO: detect multiple stores to the same target, only keep first (if target is not I/O memory)
+            // TODO: detect multiple float ffrom/fto to the same target, only keep first
+            // TODO: detect multiple sequential rnd with same reg1, only keep one
+            // TODO: detect subsequent same xors/nots/negs, remove the pairs completely as they cancel out
+            // TODO: detect multiple same ands, ors; only keep first
+            // ...
+        }
+        return changed
+    }
+}
+
+private interface ICodeChange { // TODO not used? remove?
+    fun perform(block: VmCodeChunk)
+
+    class Remove(val idx: Int): ICodeChange {
+        override fun perform(block: VmCodeChunk) {
+            block.lines.removeAt(idx)
+        }
+    }
+}
@@ -0,0 +1,19 @@
+package prog8tests.vm.helpers
+
+import prog8.code.core.*
+
+
+internal object DummyMemsizer : IMemSizer {
+    override fun memorySize(dt: DataType) = 0
+    override fun memorySize(arrayDt: DataType, numElements: Int) = 0
+}
+
+internal object DummyStringEncoder : IStringEncoding {
+    override fun encodeString(str: String, encoding: Encoding): List<UByte> {
+        return emptyList()
+    }
+
+    override fun decodeString(bytes: List<UByte>, encoding: Encoding): String {
+        return ""
+    }
+}
@@ -0,0 +1,171 @@
+package prog8tests.vm
+
+import io.kotest.assertions.fail
+import io.kotest.core.spec.style.FunSpec
+import io.kotest.matchers.shouldBe
+import prog8.code.SymbolTable
+import prog8.code.ast.PtProgram
+import prog8.codegen.virtual.*
+import prog8.vm.Opcode
+import prog8.vm.VmDataType
+import prog8tests.vm.helpers.DummyMemsizer
+import prog8tests.vm.helpers.DummyStringEncoder
+
+class TestVmPeepholeOpt: FunSpec({
+    fun makeVmProgram(lines: List<VmCodeLine>): Pair<AssemblyProgram, VariableAllocator> {
+        val st = SymbolTable()
+        val program = PtProgram("test", DummyMemsizer, DummyStringEncoder)
+        val allocations = VariableAllocator(st, program)
+        val asm = AssemblyProgram("test", allocations)
+        val block = VmCodeChunk()
+        for(line in lines)
+            block += line
+        asm.addBlock(block)
+        return Pair(asm, allocations)
+    }
+
+    fun AssemblyProgram.lines(): List<VmCodeLine> = this.getBlocks().flatMap { it.lines }
+
+    test("remove nops") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = listOf("dummy")),
+            VmCodeInstruction(Opcode.NOP),
+            VmCodeInstruction(Opcode.NOP)
+        ))
+        asm.lines().size shouldBe 3
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        asm.lines().size shouldBe 1
+    }
+
+    test("remove jmp to label below") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = listOf("label")),  // removed
+            VmCodeLabel(listOf("label")),
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = listOf("label2")), // removed
+            VmCodeInstruction(Opcode.NOP),  // removed
+            VmCodeLabel(listOf("label2")),
+            VmCodeInstruction(Opcode.JUMP, labelSymbol = listOf("label3")),
+            VmCodeInstruction(Opcode.INC, VmDataType.BYTE, reg1=1),
+            VmCodeLabel(listOf("label3"))
+        ))
+        asm.lines().size shouldBe 8
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 5
+        (lines[0] as VmCodeLabel).name shouldBe listOf("label")
+        (lines[1] as VmCodeLabel).name shouldBe listOf("label2")
+        (lines[2] as VmCodeInstruction).ins.opcode shouldBe Opcode.JUMP
+        (lines[3] as VmCodeInstruction).ins.opcode shouldBe Opcode.INC
+        (lines[4] as VmCodeLabel).name shouldBe listOf("label3")
+    }
+
+    test("remove double sec/clc") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.SEC),
+            VmCodeInstruction(Opcode.SEC),
+            VmCodeInstruction(Opcode.SEC),
+            VmCodeInstruction(Opcode.CLC),
+            VmCodeInstruction(Opcode.CLC),
+            VmCodeInstruction(Opcode.CLC)
+        ))
+        asm.lines().size shouldBe 6
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 1
+        (lines[0] as VmCodeInstruction).ins.opcode shouldBe Opcode.CLC
+    }
+
+    test("push followed by pop") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.PUSH, VmDataType.BYTE, reg1=42),
+            VmCodeInstruction(Opcode.POP, VmDataType.BYTE, reg1=42),
+            VmCodeInstruction(Opcode.PUSH, VmDataType.BYTE, reg1=99),
+            VmCodeInstruction(Opcode.POP, VmDataType.BYTE, reg1=222)
+        ))
+        asm.lines().size shouldBe 4
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 1
+        (lines[0] as VmCodeInstruction).ins.opcode shouldBe Opcode.LOADR
+        (lines[0] as VmCodeInstruction).ins.reg1 shouldBe 222
+        (lines[0] as VmCodeInstruction).ins.reg2 shouldBe 99
+    }
+
+    test("remove useless div/mul, add/sub") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.DIV, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.DIVS, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.MUL, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.MOD, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.DIV, VmDataType.BYTE, reg1=42, value = 2),
+            VmCodeInstruction(Opcode.DIVS, VmDataType.BYTE, reg1=42, value = 2),
+            VmCodeInstruction(Opcode.MUL, VmDataType.BYTE, reg1=42, value = 2),
+            VmCodeInstruction(Opcode.MOD, VmDataType.BYTE, reg1=42, value = 2),
+            VmCodeInstruction(Opcode.ADD, VmDataType.BYTE, reg1=42, value = 0),
+            VmCodeInstruction(Opcode.SUB, VmDataType.BYTE, reg1=42, value = 0)
+        ))
+        asm.lines().size shouldBe 10
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 4
+    }
+
+    test("replace add/sub 1 by inc/dec") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.ADD, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.SUB, VmDataType.BYTE, reg1=42, value = 1)
+        ))
+        asm.lines().size shouldBe 2
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 2
+        (lines[0] as VmCodeInstruction).ins.opcode shouldBe Opcode.INC
+        (lines[1] as VmCodeInstruction).ins.opcode shouldBe Opcode.DEC
+    }
+
+    test("remove useless and/or/xor") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.AND, VmDataType.BYTE, reg1=42, value = 255),
+            VmCodeInstruction(Opcode.AND, VmDataType.WORD, reg1=42, value = 65535),
+            VmCodeInstruction(Opcode.OR, VmDataType.BYTE, reg1=42, value = 0),
+            VmCodeInstruction(Opcode.XOR, VmDataType.BYTE, reg1=42, value = 0),
+            VmCodeInstruction(Opcode.AND, VmDataType.BYTE, reg1=42, value = 200),
+            VmCodeInstruction(Opcode.AND, VmDataType.WORD, reg1=42, value = 60000),
+            VmCodeInstruction(Opcode.OR, VmDataType.BYTE, reg1=42, value = 1),
+            VmCodeInstruction(Opcode.XOR, VmDataType.BYTE, reg1=42, value = 1)
+        ))
+        asm.lines().size shouldBe 8
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 4
+    }
+
+    test("replace and/or/xor by constant number") {
+        val(asm, allocations) = makeVmProgram(listOf(
+            VmCodeInstruction(Opcode.AND, VmDataType.BYTE, reg1=42, value = 0),
+            VmCodeInstruction(Opcode.AND, VmDataType.WORD, reg1=42, value = 0),
+            VmCodeInstruction(Opcode.OR, VmDataType.BYTE, reg1=42, value = 255),
+            VmCodeInstruction(Opcode.OR, VmDataType.WORD, reg1=42, value = 65535)
+        ))
+        asm.lines().size shouldBe 4
+        val opt = VmPeepholeOptimizer(asm, allocations)
+        opt.optimize()
+        val lines = asm.lines()
+        lines.size shouldBe 4
+        (lines[0] as VmCodeInstruction).ins.opcode shouldBe Opcode.LOAD
+        (lines[1] as VmCodeInstruction).ins.opcode shouldBe Opcode.LOAD
+        (lines[2] as VmCodeInstruction).ins.opcode shouldBe Opcode.LOAD
+        (lines[3] as VmCodeInstruction).ins.opcode shouldBe Opcode.LOAD
+        (lines[0] as VmCodeInstruction).ins.value shouldBe 0
+        (lines[1] as VmCodeInstruction).ins.value shouldBe 0
+        (lines[2] as VmCodeInstruction).ins.value shouldBe 255
+        (lines[3] as VmCodeInstruction).ins.value shouldBe 65535
+    }
+})
@@ -3,7 +3,6 @@ package prog8.optimizer
 import prog8.ast.IStatementContainer
 import prog8.ast.Node
 import prog8.ast.Program
-import prog8.ast.expressions.AugmentAssignmentOperators
 import prog8.ast.expressions.BinaryExpression
 import prog8.ast.expressions.IdentifierReference
 import prog8.ast.expressions.TypecastExpression
@@ -13,6 +12,7 @@ import prog8.ast.statements.Assignment
 import prog8.ast.statements.AssignmentOrigin
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
+import prog8.code.core.AugmentAssignmentOperators
 import prog8.code.core.CompilationOptions
 import prog8.code.core.DataType
 import prog8.code.target.VMTarget
@@ -22,6 +22,9 @@ class BinExprSplitter(private val program: Program, private val options: Compila

    override fun after(assignment: Assignment, parent: Node): Iterable<IAstModification> {

+        if(options.compTarget.name == VMTarget.NAME)
+            return noModifications  // don't split expressions when targeting the vm codegen, it handles nested expressions well
+
        if(assignment.value.inferType(program) istype DataType.FLOAT && !options.optimizeFloatExpressions)
            return noModifications

@@ -97,7 +100,8 @@ X =      BinExpr                                    X   =   LeftExpr
                // we can see if we can unwrap the binary expression by working on a new temporary variable
                // (that has the type of the expression), and then finally doing the typecast.
                // Once it's outside the typecast, the regular splitting can commence.
-                val (tempVarName, _) = program.getTempVar(origExpr.inferType(program).getOr(DataType.UNDEFINED))
+                val tempvarDt = origExpr.inferType(program).getOr(DataType.UNDEFINED)
+                val (tempVarName, _) = program.getTempVar(tempvarDt)
                val assignTempVar = Assignment(
                    AssignTarget(IdentifierReference(tempVarName, typecast.position), null, null, typecast.position),
                    typecast.expression, AssignmentOrigin.OPTIMIZER, typecast.position
@@ -22,9 +22,6 @@ class ConstExprEvaluator {
                "&" -> bitwiseand(left, right)
                "|" -> bitwiseor(left, right)
                "^" -> bitwisexor(left, right)
-                "and" -> logicaland(left, right)
-                "or" -> logicalor(left, right)
-                "xor" -> logicalxor(left, right)
                "<" -> NumericLiteral.fromBoolean(left < right, left.position)
                ">" -> NumericLiteral.fromBoolean(left > right, left.position)
                "<=" -> NumericLiteral.fromBoolean(left <= right, left.position)
@@ -58,57 +55,6 @@ class ConstExprEvaluator {
        return NumericLiteral(left.type, result.toDouble(), left.position)
    }

-    private fun logicalxor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
-        val error = "cannot compute $left locical-bitxor $right"
-        return when (left.type) {
-            in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean((left.number.toInt() != 0) xor (right.number.toInt() != 0), left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean((left.number.toInt() != 0) xor (right.number != 0.0), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            DataType.FLOAT -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean((left.number != 0.0) xor (right.number.toInt() != 0), left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean((left.number != 0.0) xor (right.number != 0.0), left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun logicalor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
-        val error = "cannot compute $left locical-or $right"
-        return when (left.type) {
-            in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean(left.number.toInt() != 0 || right.number.toInt() != 0, left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean(left.number.toInt() != 0 || right.number != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            DataType.FLOAT -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean(left.number != 0.0 || right.number.toInt() != 0, left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean(left.number != 0.0 || right.number != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
-    private fun logicaland(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
-        val error = "cannot compute $left locical-and $right"
-        return when (left.type) {
-            in IntegerDatatypes -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean(left.number.toInt() != 0 && right.number.toInt() != 0, left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean(left.number.toInt() != 0 && right.number != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            DataType.FLOAT -> when (right.type) {
-                in IntegerDatatypes -> NumericLiteral.fromBoolean(left.number != 0.0 && right.number.toInt() != 0, left.position)
-                DataType.FLOAT -> NumericLiteral.fromBoolean(left.number != 0.0 && right.number != 0.0, left.position)
-                else -> throw ExpressionError(error, left.position)
-            }
-            else -> throw ExpressionError(error, left.position)
-        }
-    }
-
    private fun bitwisexor(left: NumericLiteral, right: NumericLiteral): NumericLiteral {
        if(left.type== DataType.UBYTE) {
            if(right.type in IntegerDatatypes) {
@@ -1,18 +1,15 @@
 package prog8.optimizer

-import prog8.ast.Node
-import prog8.ast.Program
-import prog8.ast.base.ExpressionError
+import prog8.ast.*
 import prog8.ast.base.FatalAstException
 import prog8.ast.base.UndefinedSymbolError
 import prog8.ast.expressions.*
-import prog8.ast.statements.ForLoop
-import prog8.ast.statements.VarDecl
-import prog8.ast.statements.VarDeclType
+import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
+import prog8.code.core.AssociativeOperators
 import prog8.code.core.DataType
-import prog8.code.core.IntegerDatatypes
+import prog8.compiler.BuiltinFunctions


 class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
@@ -34,59 +31,8 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
    }

    override fun after(expr: PrefixExpression, parent: Node): Iterable<IAstModification> {
-        // Try to turn a unary prefix expression into a single constant value.
-        // Compile-time constant sub expressions will be evaluated on the spot.
-        // For instance, the expression for "- 4.5" will be optimized into the float literal -4.5
-        val subexpr = expr.expression
-        if (subexpr is NumericLiteral) {
-            // accept prefixed literal values (such as -3, not true)
-            return when (expr.operator) {
-                "+" -> listOf(IAstModification.ReplaceNode(expr, subexpr, parent))
-                "-" -> when (subexpr.type) {
-                    in IntegerDatatypes -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral.optimalInteger(-subexpr.number.toInt(), subexpr.position),
-                                parent))
-                    }
-                    DataType.FLOAT -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral(DataType.FLOAT, -subexpr.number, subexpr.position),
-                                parent))
-                    }
-                    else -> throw ExpressionError("can only take negative of int or float", subexpr.position)
-                }
-                "~" -> when (subexpr.type) {
-                    DataType.BYTE -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral(DataType.BYTE, subexpr.number.toInt().inv().toDouble(), subexpr.position),
-                                parent))
-                    }
-                    DataType.UBYTE -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral(DataType.UBYTE, (subexpr.number.toInt().inv() and 255).toDouble(), subexpr.position),
-                                parent))
-                    }
-                    DataType.WORD -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral(DataType.WORD, subexpr.number.toInt().inv().toDouble(), subexpr.position),
-                                parent))
-                    }
-                    DataType.UWORD -> {
-                        listOf(IAstModification.ReplaceNode(expr,
-                                NumericLiteral(DataType.UWORD, (subexpr.number.toInt().inv() and 65535).toDouble(), subexpr.position),
-                                parent))
-                    }
-                    else -> throw ExpressionError("can only take bitwise inversion of int", subexpr.position)
-                }
-                "not" -> {
-                    listOf(IAstModification.ReplaceNode(expr,
-                            NumericLiteral.fromBoolean(subexpr.number == 0.0, subexpr.position),
-                            parent))
-                }
-                else -> throw ExpressionError(expr.operator, subexpr.position)
-            }
-        }
-        return noModifications
+        val constValue = expr.constValue(program) ?: return noModifications
+        return listOf(IAstModification.ReplaceNode(expr, constValue, parent))
    }

    /*
@@ -107,9 +53,32 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
     *        (X + c1) - c2  ->  X + (c1-c2)
     */
    override fun after(expr: BinaryExpression, parent: Node): Iterable<IAstModification> {
+        val modifications = mutableListOf<IAstModification>()
        val leftconst = expr.left.constValue(program)
        val rightconst = expr.right.constValue(program)
-        val modifications = mutableListOf<IAstModification>()
+
+        if(expr.left.inferType(program) istype DataType.STR) {
+            if(expr.operator=="+" && expr.left is StringLiteral && expr.right is StringLiteral) {
+                // concatenate two strings.
+                val leftString = expr.left as StringLiteral
+                val rightString = expr.right as StringLiteral
+                val concatenated = if(leftString.encoding==rightString.encoding) {
+                    leftString.value + rightString.value
+                } else {
+                    program.encoding.decodeString(
+                        program.encoding.encodeString(leftString.value, leftString.encoding) + program.encoding.encodeString(rightString.value, rightString.encoding),
+                        leftString.encoding)
+                }
+                val concatStr = StringLiteral(concatenated, leftString.encoding, expr.position)
+                return listOf(IAstModification.ReplaceNode(expr, concatStr, parent))
+            }
+            else if(expr.operator=="*" && rightconst!=null && expr.left is StringLiteral) {
+                // mutiply a string.
+                val part = expr.left as StringLiteral
+                val newStr = StringLiteral(part.value.repeat(rightconst.number.toInt()), part.encoding, expr.position)
+                return listOf(IAstModification.ReplaceNode(expr, newStr, parent))
+            }
+        }

        if(expr.operator=="==" && rightconst!=null) {
            val leftExpr = expr.left as? BinaryExpression
@@ -168,6 +137,21 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
            modifications += IAstModification.ReplaceNode(expr, result, parent)
        }

+        if(leftconst==null && rightconst!=null && rightconst.number<0.0) {
+            if (expr.operator == "-") {
+                // X - -1 ---> X + 1
+                val posNumber = NumericLiteral.optimalNumeric(-rightconst.number, rightconst.position)
+                val plusExpr = BinaryExpression(expr.left, "+", posNumber, expr.position)
+                return listOf(IAstModification.ReplaceNode(expr, plusExpr, parent))
+            }
+            else if (expr.operator == "+") {
+                // X + -1 ---> X - 1
+                val posNumber = NumericLiteral.optimalNumeric(-rightconst.number, rightconst.position)
+                val plusExpr = BinaryExpression(expr.left, "-", posNumber, expr.position)
+                return listOf(IAstModification.ReplaceNode(expr, plusExpr, parent))
+            }
+        }
+

        val leftBinExpr = expr.left as? BinaryExpression
        val rightBinExpr = expr.right as? BinaryExpression
@@ -278,7 +262,6 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
    }

    override fun after(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
-        // the args of a fuction are constfolded via recursion already.
        val constvalue = functionCallExpr.constValue(program)
        return if(constvalue!=null)
            listOf(IAstModification.ReplaceNode(functionCallExpr, constvalue, parent))
@@ -286,6 +269,14 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
            noModifications
    }

+    override fun after(bfc: BuiltinFunctionCall, parent: Node): Iterable<IAstModification> {
+        val constvalue = bfc.constValue(program)
+        return if(constvalue!=null)
+            listOf(IAstModification.ReplaceNode(bfc, constvalue, parent))
+        else
+            noModifications
+    }
+
    override fun after(forLoop: ForLoop, parent: Node): Iterable<IAstModification> {
        fun adjustRangeDt(rangeFrom: NumericLiteral, targetDt: DataType, rangeTo: NumericLiteral, stepLiteral: NumericLiteral?, range: RangeExpression): RangeExpression? {
            val fromCast = rangeFrom.cast(targetDt)
@@ -399,7 +390,7 @@ class ConstantFoldingOptimizer(private val program: Program) : AstWalker() {
            // both operators are the same.

            // If associative,  we can simply shuffle the const operands around to optimize.
-            if(expr.operator in AssociativeOperators) {
+            if(expr.operator in AssociativeOperators && maySwapOperandOrder(expr)) {
                return if(leftIsConst) {
                    if(subleftIsConst)
                        ShuffleOperands(expr, null, subExpr, subExpr.right, null, null, expr.left)
@@ -1,22 +1,25 @@
 package prog8.optimizer

-import prog8.ast.*
+import prog8.ast.IStatementContainer
+import prog8.ast.Node
+import prog8.ast.Program
 import prog8.ast.base.FatalAstException
 import prog8.ast.expressions.*
-import prog8.ast.statements.*
+import prog8.ast.maySwapOperandOrder
+import prog8.ast.statements.AnonymousScope
+import prog8.ast.statements.Assignment
+import prog8.ast.statements.IfElse
+import prog8.ast.statements.Jump
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
-import prog8.code.core.DataType
-import prog8.code.core.IErrorReporter
-import prog8.code.core.IntegerDatatypes
-import prog8.code.core.NumericDatatypes
+import prog8.code.core.*
 import kotlin.math.abs
 import kotlin.math.log2
 import kotlin.math.pow

 // TODO add more peephole expression optimizations? Investigate what optimizations binaryen has, also see  https://egorbo.com/peephole-optimizations.html

-class ExpressionSimplifier(private val program: Program, private val errors: IErrorReporter) : AstWalker() {
+class ExpressionSimplifier(private val program: Program) : AstWalker() {
    private val powersOfTwo = (1..16).map { (2.0).pow(it) }.toSet()
    private val negativePowersOfTwo = powersOfTwo.map { -it }.toSet()

@@ -27,8 +30,9 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
        val literal = typecast.expression as? NumericLiteral
        if (literal != null) {
            val newLiteral = literal.cast(typecast.type)
-            if (newLiteral.isValid && newLiteral.valueOrZero() !== literal)
-                mods += IAstModification.ReplaceNode(typecast.expression, newLiteral.valueOrZero(), typecast)
+            if (newLiteral.isValid && newLiteral.valueOrZero() !== literal) {
+                mods += IAstModification.ReplaceNode(typecast, newLiteral.valueOrZero(), parent)
+            }
        }

        // remove redundant nested typecasts
@@ -83,12 +87,12 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
            throw FatalAstException("can't determine datatype of both expression operands $expr")

        // ConstValue <associativeoperator> X -->  X <associativeoperator> ConstValue
-        if (leftVal != null && expr.operator in AssociativeOperators && rightVal == null)
+        if (leftVal != null && expr.operator in AssociativeOperators && rightVal == null && maySwapOperandOrder(expr))
            return listOf(IAstModification.SwapOperands(expr))

        // NonBinaryExpression  <associativeoperator>  BinaryExpression  -->  BinaryExpression  <associativeoperator>  NonBinaryExpression
        if (expr.operator in AssociativeOperators && expr.left !is BinaryExpression && expr.right is BinaryExpression) {
-            if(parent !is Assignment || !(expr.left isSameAs parent.target))
+            if(parent !is Assignment || !(expr.left isSameAs parent.target) && maySwapOperandOrder(expr))
                return listOf(IAstModification.SwapOperands(expr))
        }

@@ -190,35 +194,19 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
            }
        }

+        // boolvar & 1  --> boolvar
+        // boolvar & 2  --> false
+        if(expr.operator=="&" && rightDt in IntegerDatatypes && (leftDt == DataType.BOOL || (expr.left as? TypecastExpression)?.expression?.inferType(program)?.istype(DataType.BOOL)==true)) {
+            if(rightVal?.number==1.0) {
+                return listOf(IAstModification.ReplaceNode(expr, expr.left, parent))
+            } else if(rightVal?.number!=null && (rightVal.number.toInt() and 1)==0) {
+                return listOf(IAstModification.ReplaceNode(expr, NumericLiteral.fromBoolean(false, expr.position), parent))
+            }
+        }
+
        // simplify when a term is constant and directly determines the outcome
-        val constTrue = NumericLiteral.fromBoolean(true, expr.position)
        val constFalse = NumericLiteral.fromBoolean(false, expr.position)
        val newExpr: Expression? = when (expr.operator) {
-            "or" -> {
-                when {
-                    leftVal != null && leftVal.asBooleanValue || rightVal != null && rightVal.asBooleanValue -> constTrue
-                    leftVal != null && !leftVal.asBooleanValue -> expr.right
-                    rightVal != null && !rightVal.asBooleanValue -> expr.left
-                    else -> null
-                }
-            }
-            "and" -> {
-                when {
-                    leftVal != null && !leftVal.asBooleanValue || rightVal != null && !rightVal.asBooleanValue -> constFalse
-                    leftVal != null && leftVal.asBooleanValue -> expr.right
-                    rightVal != null && rightVal.asBooleanValue -> expr.left
-                    else -> null
-                }
-            }
-            "xor" -> {
-                when {
-                    leftVal != null && !leftVal.asBooleanValue -> expr.right
-                    rightVal != null && !rightVal.asBooleanValue -> expr.left
-                    leftVal != null && leftVal.asBooleanValue -> PrefixExpression("not", expr.right, expr.right.position)
-                    rightVal != null && rightVal.asBooleanValue -> PrefixExpression("not", expr.left, expr.left.position)
-                    else -> null
-                }
-            }
            "|" -> {
                when {
                    leftVal?.number==0.0 -> expr.right
@@ -262,6 +250,28 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
            else -> null
        }

+        if(rightVal!=null && leftDt==DataType.BOOL) {
+            // see if we can replace comparison against true/1 with simpler comparison against zero
+            if (expr.operator == "==") {
+                if (rightVal.number == 1.0) {
+                    val zero = NumericLiteral(DataType.UBYTE, 0.0, expr.right.position)
+                    return listOf(
+                        IAstModification.SetExpression({expr.operator="!="}, expr, parent),
+                        IAstModification.ReplaceNode(expr.right, zero, expr)
+                    )
+                }
+            }
+            if (expr.operator == "!=") {
+                if (rightVal.number == 1.0) {
+                    val zero = NumericLiteral(DataType.UBYTE, 0.0, expr.right.position)
+                    return listOf(
+                        IAstModification.SetExpression({expr.operator="=="}, expr, parent),
+                        IAstModification.ReplaceNode(expr.right, zero, expr)
+                    )
+                }
+            }
+        }
+
        if(newExpr != null)
            return listOf(IAstModification.ReplaceNode(expr, newExpr, parent))

@@ -270,6 +280,8 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr

    override fun after(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
        if(functionCallExpr.target.nameInSource == listOf("lsb")) {
+            if(functionCallExpr.args.isEmpty())
+                return noModifications
            val arg = functionCallExpr.args[0]
            if(arg is TypecastExpression) {
                val valueDt = arg.expression.inferType(program)
@@ -278,6 +290,12 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
                    return listOf(IAstModification.ReplaceNode(functionCallExpr, arg.expression, parent))
                }
            } else {
+                if(arg is IdentifierReference && arg.nameInSource.size==2
+                    && arg.nameInSource[0]=="cx16" && arg.nameInSource[1].uppercase() in RegisterOrPair.names) {
+                    // lsb(cx16.r0) -> cx16.r0L
+                    val highReg = IdentifierReference(listOf("cx16", arg.nameInSource[1]+'L'), arg.position)
+                    return listOf(IAstModification.ReplaceNode(functionCallExpr, highReg, parent))
+                }
                val argDt = arg.inferType(program)
                if (argDt istype DataType.BYTE || argDt istype DataType.UBYTE) {
                    // useless lsb() of byte value
@@ -286,6 +304,8 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
            }
        }
        else if(functionCallExpr.target.nameInSource == listOf("msb")) {
+            if(functionCallExpr.args.isEmpty())
+                return noModifications
            val arg = functionCallExpr.args[0]
            if(arg is TypecastExpression) {
                val valueDt = arg.expression.inferType(program)
@@ -297,6 +317,12 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
                            parent))
                }
            } else {
+                if(arg is IdentifierReference && arg.nameInSource.size==2
+                    && arg.nameInSource[0]=="cx16" && arg.nameInSource[1].uppercase() in RegisterOrPair.names) {
+                    // msb(cx16.r0) -> cx16.r0H
+                    val highReg = IdentifierReference(listOf("cx16", arg.nameInSource[1]+'H'), arg.position)
+                    return listOf(IAstModification.ReplaceNode(functionCallExpr, highReg, parent))
+                }
                val argDt = arg.inferType(program)
                if (argDt istype DataType.BYTE || argDt istype DataType.UBYTE) {
                    // useless msb() of byte value, replace with 0
@@ -311,49 +337,6 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
        return noModifications
    }

-    override fun after(containment: ContainmentCheck, parent: Node): Iterable<IAstModification> {
-        val range = containment.iterable as? RangeExpression
-        if(range!=null && range.step.constValue(program)?.number==1.0) {
-            val from = range.from.constValue(program)
-            val to = range.to.constValue(program)
-            val value = containment.element
-            if(from!=null && to!=null && value.isSimple) {
-                if(to.number-from.number>6.0) {
-                    // replace containment test with X>=from and X<=to
-                    val left = BinaryExpression(value, ">=", from, containment.position)
-                    val right = BinaryExpression(value.copy(), "<=", to, containment.position)
-                    val comparison = BinaryExpression(left, "and", right, containment.position)
-                    return listOf(IAstModification.ReplaceNode(containment, comparison, parent))
-                }
-            }
-        }
-        return noModifications
-    }
-
-    override fun after(pipeExpr: PipeExpression, parent: Node) = processPipe(pipeExpr, parent)
-    override fun after(pipe: Pipe, parent: Node) = processPipe(pipe, parent)
-
-    private fun processPipe(pipe: IPipe, parent: Node): Iterable<IAstModification> {
-        if(pipe.source.isSimple) {
-            val segments = pipe.segments
-            if(segments.size==1) {
-                // replace the whole pipe with a normal function call
-                val funcname = (segments[0] as IFunctionCall).target
-                val call = if(pipe is Pipe)
-                    FunctionCallStatement(funcname, mutableListOf(pipe.source), true, pipe.position)
-                else
-                    FunctionCallExpression(funcname, mutableListOf(pipe.source), pipe.position)
-                return listOf(IAstModification.ReplaceNode(pipe as Node, call, parent))
-            } else if(segments.size>1) {
-                // replace source+firstsegment by firstsegment(source) call as the new source
-                val firstSegment = segments.removeAt(0) as IFunctionCall
-                val call = FunctionCallExpression(firstSegment.target, mutableListOf(pipe.source), pipe.position)
-                return listOf(IAstModification.ReplaceNode(pipe.source, call, pipe as Node))
-            }
-        }
-        return noModifications
-    }
-
    private fun determineY(x: Expression, subBinExpr: BinaryExpression): Expression? {
        return when {
            subBinExpr.left isSameAs x -> subBinExpr.right
@@ -645,7 +628,7 @@ class ExpressionSimplifier(private val program: Program, private val errors: IEr
    }

    private fun reorderAssociativeWithConstant(expr: BinaryExpression, leftVal: NumericLiteral?): BinExprWithConstants {
-        if (expr.operator in AssociativeOperators && leftVal != null) {
+        if (expr.operator in AssociativeOperators && leftVal != null && maySwapOperandOrder(expr)) {
            // swap left and right so that right is always the constant
            val tmp = expr.left
            expr.left = expr.right
@@ -54,8 +54,14 @@ fun Program.optimizeStatements(errors: IErrorReporter,
    return optimizationCount
 }

-fun Program.simplifyExpressions(errors: IErrorReporter) : Int {
-    val opti = ExpressionSimplifier(this, errors)
+fun Program.inlineSubroutines(): Int {
+    val inliner = Inliner(this)
+    inliner.visit(this)
+    return inliner.applyModifications()
+}
+
+fun Program.simplifyExpressions() : Int {
+    val opti = ExpressionSimplifier(this)
    opti.visit(this)
    return opti.applyModifications()
 }
@@ -0,0 +1,241 @@
+package prog8.optimizer
+
+import prog8.ast.IFunctionCall
+import prog8.ast.Node
+import prog8.ast.Program
+import prog8.ast.expressions.*
+import prog8.ast.statements.*
+import prog8.ast.walk.AstWalker
+import prog8.ast.walk.IAstModification
+import prog8.ast.walk.IAstVisitor
+import prog8.code.core.InternalCompilerException
+
+
+private  fun isEmptyReturn(stmt: Statement): Boolean = stmt is Return && stmt.value==null
+
+
+// inliner potentially enables *ONE LINED* subroutines, wihtout to be inlined.
+
+class Inliner(val program: Program): AstWalker() {
+
+    class DetermineInlineSubs(val program: Program): IAstVisitor {
+        private val modifications = mutableListOf<IAstModification>()
+
+        init {
+            visit(program)
+            modifications.forEach { it.perform() }
+            modifications.clear()
+        }
+
+        override fun visit(subroutine: Subroutine) {
+            if(!subroutine.isAsmSubroutine && !subroutine.inline && subroutine.parameters.isEmpty()) {
+                val containsSubsOrVariables = subroutine.statements.any { it is VarDecl || it is Subroutine}
+                if(!containsSubsOrVariables) {
+                    if(subroutine.statements.size==1 || (subroutine.statements.size==2 && isEmptyReturn(subroutine.statements[1]))) {
+                        // subroutine is possible candidate to be inlined
+                        subroutine.inline =
+                            when(val stmt=subroutine.statements[0]) {
+                                is Return -> {
+                                    if(stmt.value is NumericLiteral)
+                                        true
+                                    else if (stmt.value is IdentifierReference) {
+                                        makeFullyScoped(stmt.value as IdentifierReference)
+                                        true
+                                    } else if(stmt.value!! is IFunctionCall && (stmt.value as IFunctionCall).args.size<=1 && (stmt.value as IFunctionCall).args.all { it is NumericLiteral || it is IdentifierReference }) {
+                                        when (stmt.value) {
+                                            is BuiltinFunctionCall -> {
+                                                makeFullyScoped(stmt.value as BuiltinFunctionCall)
+                                                true
+                                            }
+                                            is FunctionCallExpression -> {
+                                                makeFullyScoped(stmt.value as FunctionCallExpression)
+                                                true
+                                            }
+                                            else -> false
+                                        }
+                                    } else
+                                        false
+                                }
+                                is Assignment -> {
+                                    if(stmt.value.isSimple) {
+                                        val targetInline =
+                                            if(stmt.target.identifier!=null) {
+                                                makeFullyScoped(stmt.target.identifier!!)
+                                                true
+                                            } else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                                if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                                    makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
+                                                true
+                                            } else
+                                                false
+                                        val valueInline =
+                                            if(stmt.value is IdentifierReference) {
+                                                makeFullyScoped(stmt.value as IdentifierReference)
+                                                true
+                                            } else if((stmt.value as? DirectMemoryRead)?.addressExpression is NumericLiteral || (stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference) {
+                                                if((stmt.value as? DirectMemoryRead)?.addressExpression is IdentifierReference)
+                                                    makeFullyScoped((stmt.value as? DirectMemoryRead)?.addressExpression as IdentifierReference)
+                                                true
+                                            } else
+                                                false
+                                        targetInline || valueInline
+                                    } else
+                                        false
+                                }
+                                is BuiltinFunctionCallStatement -> {
+                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                    if(inline)
+                                        makeFullyScoped(stmt)
+                                    inline
+                                }
+                                is FunctionCallStatement -> {
+                                    val inline = stmt.args.size<=1 && stmt.args.all { it is NumericLiteral || it is IdentifierReference }
+                                    if(inline)
+                                        makeFullyScoped(stmt)
+                                    inline
+                                }
+                                is PostIncrDecr -> {
+                                    if(stmt.target.identifier!=null) {
+                                        makeFullyScoped(stmt.target.identifier!!)
+                                        true
+                                    }
+                                    else if(stmt.target.memoryAddress?.addressExpression is NumericLiteral || stmt.target.memoryAddress?.addressExpression is IdentifierReference) {
+                                        if(stmt.target.memoryAddress?.addressExpression is IdentifierReference)
+                                            makeFullyScoped(stmt.target.memoryAddress?.addressExpression as IdentifierReference)
+                                        true
+                                    } else
+                                        false
+                                }
+                                is Jump, is GoSub -> true
+                                else -> false
+                            }
+                    }
+                }
+            }
+            super.visit(subroutine)
+        }
+
+        private fun makeFullyScoped(identifier: IdentifierReference) {
+            val scoped = (identifier.targetStatement(program)!! as INamedStatement).scopedName
+            val scopedIdent = IdentifierReference(scoped, identifier.position)
+            modifications += IAstModification.ReplaceNode(identifier, scopedIdent, identifier.parent)
+        }
+
+        private fun makeFullyScoped(call: BuiltinFunctionCallStatement) {
+            val scopedArgs = makeScopedArgs(call.args)
+            val scopedCall = BuiltinFunctionCallStatement(call.target.copy(), scopedArgs.toMutableList(), call.position)
+            modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+        }
+
+        private fun makeFullyScoped(call: FunctionCallStatement) {
+            val sub = call.target.targetSubroutine(program)!!
+            val scopedName = IdentifierReference(sub.scopedName, call.target.position)
+            val scopedArgs = makeScopedArgs(call.args)
+            val scopedCall = FunctionCallStatement(scopedName, scopedArgs.toMutableList(), call.void, call.position)
+            modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+        }
+
+        private fun makeFullyScoped(call: BuiltinFunctionCall) {
+            val sub = call.target.targetSubroutine(program)!!
+            val scopedName = IdentifierReference(sub.scopedName, call.target.position)
+            val scopedArgs = makeScopedArgs(call.args)
+            val scopedCall = BuiltinFunctionCall(scopedName, scopedArgs.toMutableList(), call.position)
+            modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+        }
+
+        private fun makeFullyScoped(call: FunctionCallExpression) {
+            val sub = call.target.targetSubroutine(program)!!
+            val scopedName = IdentifierReference(sub.scopedName, call.target.position)
+            val scopedArgs = makeScopedArgs(call.args)
+            val scopedCall = FunctionCallExpression(scopedName, scopedArgs.toMutableList(), call.position)
+            modifications += IAstModification.ReplaceNode(call, scopedCall, call.parent)
+        }
+
+        private fun makeScopedArgs(args: List<Expression>): List<Expression> {
+            return args.map {
+                when (it) {
+                    is NumericLiteral -> it.copy()
+                    is IdentifierReference -> {
+                        val scoped = (it.targetStatement(program)!! as INamedStatement).scopedName
+                        IdentifierReference(scoped, it.position)
+                    }
+                    else -> throw InternalCompilerException("expected only number or identifier arg, otherwise too complex")
+                }
+            }
+        }
+    }
+
+    override fun before(program: Program): Iterable<IAstModification> {
+        DetermineInlineSubs(program)
+        return super.before(program)
+    }
+
+    override fun after(gosub: GoSub, parent: Node): Iterable<IAstModification> {
+        val sub = gosub.identifier.targetStatement(program) as? Subroutine
+        return if(sub==null)
+            noModifications
+        else
+            possibleInlineFcallStmt(sub, gosub, parent)
+
+    }
+
+    private fun possibleInlineFcallStmt(sub: Subroutine, origNode: Node, parent: Node): Iterable<IAstModification> {
+        if(sub.inline && sub.parameters.isEmpty()) {
+            require(sub.statements.size == 1 || (sub.statements.size == 2 && isEmptyReturn(sub.statements[1])))
+            return if(sub.isAsmSubroutine) {
+                // simply insert the asm for the argument-less routine
+                listOf(IAstModification.ReplaceNode(origNode, sub.statements.single().copy(), parent))
+            } else {
+                // note that we don't have to process any args, because we online inline parameterless subroutines.
+                when (val toInline = sub.statements.first()) {
+                    is Return -> {
+                        val fcall = toInline.value as? FunctionCallExpression
+                        if(fcall!=null) {
+                            // insert the function call expression as a void function call directly
+                            val call = FunctionCallStatement(fcall.target.copy(), fcall.args.map { it.copy() }.toMutableList(), true, fcall.position)
+                            listOf(IAstModification.ReplaceNode(origNode, call, parent))
+                        } else
+                            noModifications
+                    }
+                    else -> listOf(IAstModification.ReplaceNode(origNode, toInline.copy(), parent))
+                }
+            }
+        }
+        return noModifications
+    }
+
+    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification>  {
+        val sub = functionCallStatement.target.targetStatement(program) as? Subroutine
+        return if(sub==null)
+            noModifications
+        else
+            possibleInlineFcallStmt(sub, functionCallStatement, parent)
+    }
+
+    override fun before(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
+        val sub = functionCallExpr.target.targetStatement(program) as? Subroutine
+        if(sub!=null && sub.inline && sub.parameters.isEmpty()) {
+            require(sub.statements.size==1 || (sub.statements.size==2 && isEmptyReturn(sub.statements[1])))
+            return if(sub.isAsmSubroutine) {
+                // cannot inline assembly directly in the Ast here as an Asm node is not an expression....
+                noModifications
+            } else {
+                when (val toInline = sub.statements.first()) {
+                    is Return -> {
+                        // is an expression, so we have to have a Return here in the inlined sub
+                        // note that we don't have to process any args, because we online inline parameterless subroutines.
+                        if(toInline.value!=null)
+                            listOf(IAstModification.ReplaceNode(functionCallExpr, toInline.value!!.copy(), parent))
+                        else
+                            noModifications
+                    }
+                    else -> noModifications
+                }
+            }
+        }
+
+        return noModifications
+    }
+
+}
+
@@ -7,7 +7,6 @@ import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
 import prog8.code.core.*
 import prog8.code.target.VMTarget
-import prog8.code.target.virtual.VirtualMachineDefinition
 import kotlin.math.floor


@@ -17,46 +16,6 @@ class StatementOptimizer(private val program: Program,
                         private val compTarget: ICompilationTarget
 ) : AstWalker() {

-    override fun before(functionCallExpr: FunctionCallExpression, parent: Node): Iterable<IAstModification> {
-        // if the first instruction in the called subroutine is a return statement with a simple value (NOT being a parameter),
-        // remove the jump altogeter and inline the returnvalue directly.
-
-        fun scopePrefix(variable: IdentifierReference): IdentifierReference {
-            val target = variable.targetStatement(program) as INamedStatement
-            return IdentifierReference(target.scopedName, variable.position)
-        }
-
-        val subroutine = functionCallExpr.target.targetSubroutine(program)
-        if(subroutine!=null) {
-            val first = subroutine.statements.asSequence().filterNot { it is VarDecl || it is Directive }.firstOrNull()
-            if(first is Return && first.value?.isSimple==true) {
-                val copy = when(val orig = first.value!!) {
-                    is AddressOf -> {
-                        val scoped = scopePrefix(orig.identifier)
-                        AddressOf(scoped, orig.position)
-                    }
-                    is DirectMemoryRead -> {
-                        when(val expr = orig.addressExpression) {
-                            is NumericLiteral -> DirectMemoryRead(expr.copy(), orig.position)
-                            else -> return noModifications
-                        }
-                    }
-                    is IdentifierReference -> {
-                        if(orig.targetVarDecl(program)?.origin == VarDeclOrigin.SUBROUTINEPARAM)
-                            return noModifications
-                        else
-                            scopePrefix(orig)
-                    }
-                    is NumericLiteral -> orig.copy()
-                    is StringLiteral -> orig.copy()
-                    else -> return noModifications
-                }
-                return listOf(IAstModification.ReplaceNode(functionCallExpr, copy, parent))
-            }
-        }
-        return noModifications
-    }
-
    override fun after(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
        if(functionCallStatement.target.nameInSource.size==1) {
            val functionName = functionCallStatement.target.nameInSource[0]
@@ -149,7 +108,7 @@ class StatementOptimizer(private val program: Program,

        // empty true part? switch with the else part
        if(ifElse.truepart.isEmpty() && ifElse.elsepart.isNotEmpty()) {
-            val invertedCondition = PrefixExpression("not", ifElse.condition, ifElse.condition.position)
+            val invertedCondition = BinaryExpression(ifElse.condition, "==", NumericLiteral(DataType.UBYTE, 0.0, ifElse.condition.position), ifElse.condition.position)
            val emptyscope = AnonymousScope(mutableListOf(), ifElse.elsepart.position)
            val truepart = AnonymousScope(ifElse.elsepart.statements, ifElse.truepart.position)
            return listOf(
@@ -314,7 +273,7 @@ class StatementOptimizer(private val program: Program,
                    val op1 = binExpr.operator
                    val op2 = rExpr.operator

-                    if(rExpr.left is NumericLiteral && op2 in AssociativeOperators) {
+                    if(rExpr.left is NumericLiteral && op2 in AssociativeOperators && maySwapOperandOrder(binExpr)) {
                        // associative operator, make sure the constant numeric value is second (right)
                        return listOf(IAstModification.SwapOperands(rExpr))
                    }
@@ -353,7 +312,7 @@ class StatementOptimizer(private val program: Program,
            if(binExpr.operator in AssociativeOperators && binExpr.right isSameAs assignment.target) {
                // associative operator, swap the operands so that the assignment target is first (left)
                // unless the other operand is the same in which case we don't swap (endless loop!)
-                if (!(binExpr.left isSameAs binExpr.right))
+                if (!(binExpr.left isSameAs binExpr.right) && maySwapOperandOrder(binExpr))
                    return listOf(IAstModification.SwapOperands(binExpr))
            }

@@ -1,7 +1,10 @@
 package prog8.optimizer

 import prog8.ast.*
-import prog8.ast.expressions.*
+import prog8.ast.expressions.BinaryExpression
+import prog8.ast.expressions.NumericLiteral
+import prog8.ast.expressions.PrefixExpression
+import prog8.ast.expressions.TypecastExpression
 import prog8.ast.statements.*
 import prog8.ast.walk.AstWalker
 import prog8.ast.walk.IAstModification
@@ -28,23 +31,23 @@ class UnusedCodeRemover(private val program: Program,

    override fun before(breakStmt: Break, parent: Node): Iterable<IAstModification> {
        reportUnreachable(breakStmt)
-        return emptyList()
+        return noModifications
    }

    override fun before(jump: Jump, parent: Node): Iterable<IAstModification> {
        reportUnreachable(jump)
-        return emptyList()
+        return noModifications
    }

    override fun before(returnStmt: Return, parent: Node): Iterable<IAstModification> {
        reportUnreachable(returnStmt)
-        return emptyList()
+        return noModifications
    }

    override fun before(functionCallStatement: FunctionCallStatement, parent: Node): Iterable<IAstModification> {
        if(functionCallStatement.target.nameInSource.last() == "exit")
            reportUnreachable(functionCallStatement)
-        return emptyList()
+        return noModifications
    }

    private fun reportUnreachable(stmt: Statement) {
@@ -236,7 +239,6 @@ class UnusedCodeRemover(private val program: Program,
                                is PrefixExpression,
                                is BinaryExpression,
                                is TypecastExpression,
-                                is PipeExpression,
                                is IFunctionCall -> { /* don't remove */ }
                                else -> {
                                    if(assign1.value !is IFunctionCall)
@@ -34,13 +34,13 @@ dependencies {
    implementation project(':codeGenCpu6502')
    implementation project(':codeGenVirtual')
    implementation project(':codeGenExperimental')
-    implementation 'org.antlr:antlr4-runtime:4.9.3'
+    implementation 'org.antlr:antlr4-runtime:4.10.1'
    implementation "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
    // implementation "org.jetbrains.kotlin:kotlin-reflect"
    implementation 'org.jetbrains.kotlinx:kotlinx-cli:0.3.4'
-    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.14"
+    implementation "com.michael-bull.kotlin-result:kotlin-result-jvm:1.1.16"

-    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.1.0'
+    testImplementation 'io.kotest:kotest-runner-junit5-jvm:5.3.2'
 }

 configurations.all {
@@ -68,7 +68,6 @@ sourceSets {
    test {
        java {
            srcDir "${project.projectDir}/test"
-            srcDir "${project(':compilerAst').projectDir}/test/helpers"
        }
    }
 }
@@ -1,8 +1,5 @@
 ; Prog8 definitions for the Atari800XL
 ; Including memory registers, I/O registers, Basic and Kernal subroutines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;

 atari {

@@ -67,6 +64,17 @@ sys {
        }}
    }

+    asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
+        ; Called when the compiler wants to assign a string value to another string.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
        ; note: only works for NON-OVERLAPPING memory regions!
        ; note: can't be inlined because is called from asm as well
@@ -1,6 +1,4 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Atari 800XL
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 %import syslib
 %import conv
@@ -116,8 +116,8 @@ cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
 		; -- cast fac1 to word into A/Y
 		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
-		ldy  $66
-		lda  $67
+		ldy  floats.AYINT_facmo
+		lda  floats.AYINT_facmo+1
 		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
@@ -168,9 +168,9 @@ stack_float2w	.proc               ; also used for float2b
 		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
 		ldx  P8ZP_SCRATCH_REG
-		lda  $66
+		lda  floats.AYINT_facmo
 		sta  P8ESTACK_HI,x
-		lda  $67
+		lda  floats.AYINT_facmo+1
 		sta  P8ESTACK_LO,x
 		dex
 		rts
@@ -1,8 +1,7 @@
 ; Prog8 definitions for floating point handling on the Commodore 128
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 %option enable_floats
+%import floats_functions

 floats {
 	; ---- this block contains C-128 compatible floating point related functions ----
@@ -110,7 +109,6 @@ asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	}}
 }

-
 asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
@@ -151,43 +149,7 @@ asmsub  FREADUY (ubyte value @Y) {
    }}
 }

-sub  print_f  (float value) {
-	; ---- prints the floating point value (without a newline).
-	%asm {{
-		stx  P8ZP_SCRATCH_REG
-		lda  #<value
-		ldy  #>value
-		jsr  MOVFM		; load float into fac1
-		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		beq  +
-		jsr  c64.CHROUT
-		iny
-		bne  -
-+		ldx  P8ZP_SCRATCH_REG
-		rts
-	}}
-}
-
-sub pow(float value, float power) -> float {
-    %asm {{
-        phx
-        phy
-        lda  #<value
-        ldy  #>value
-        jsr  floats.CONUPK
-        lda  #<power
-        ldy  #>power
-        jsr  floats.FPWR
-        ply
-        plx
-        rts
-    }}
-}
-
+&uword AYINT_facmo = $66      ; $66/$67 contain result of AYINT

 %asminclude "library:c128/floats.asm"
 %asminclude "library:c64/floats_funcs.asm"
@@ -1,8 +1,5 @@
 ; Prog8 definitions for the Commodore-128
 ; Including memory registers, I/O registers, Basic and Kernal subroutines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;

 c64 {

@@ -274,6 +271,16 @@ asmsub  disable_runstop_and_charsetswitch() clobbers(A) {
    }}
 }

+asmsub  enable_runstop_and_charsetswitch() clobbers(A) {
+    %asm {{
+        lda  #0
+        sta  247    ; enable charset switching
+        lda  #110
+        sta  808    ; enable run/stop key
+        rts
+    }}
+}
+
 asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	%asm {{
 	        sta  _modified+1
@@ -481,6 +488,13 @@ asmsub  init_system_phase2()  {
    }}
 }

+asmsub  cleanup_at_exit() {
+    ; executed when the main subroutine does rts
+    %asm {{
+        jmp  c64.enable_runstop_and_charsetswitch
+    }}
+}
+
 asmsub  disable_basic() clobbers(A) {
    %asm {{
        lda $0a04   ; disable BASIC shadow registers
@@ -554,6 +568,17 @@ sys {
        }}
    }

+    asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
+        ; Called when the compiler wants to assign a string value to another string.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
        ; note: only works for NON-OVERLAPPING memory regions!
        ; note: can't be inlined because is called from asm as well
@@ -670,7 +695,10 @@ _longcopy
    inline asmsub exit(ubyte returnvalue @A) {
        ; -- immediately exit the program with a return code in the A register
        %asm {{
+            ;lda  #14
+            ;sta  $01        ; bank the kernal in       TODO c128 how to do this?
            jsr  c64.CLRCHN		; reset i/o channels
+            jsr  c64.enable_runstop_and_charsetswitch
            ldx  prog8_lib.orig_stackpointer
            txs
            rts		; return to original caller
@@ -694,6 +722,7 @@ cx16 {
    ; $1300-$1bff is unused RAM on C128. We'll use $1a00-$1bff as the lo/hi evalstack.
    ; the virtual registers are allocated at the bottom of the eval-stack (should be ample space unless
    ; you're doing insane nesting of expressions...)
+    ; NOTE: the memory location of these registers can change based on the "-esa" compiler option
    &uword r0  = $1b00
    &uword r1  = $1b02
    &uword r2  = $1b04
@@ -1,8 +1,4 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Commodore-64
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 %import syslib
 %import conv
@@ -113,8 +113,8 @@ cast_FAC1_as_w_into_ay	.proc               ; also used for float 2 b
 		; -- cast fac1 to word into A/Y
 		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
-		ldy  $64
-		lda  $65
+		ldy  floats.AYINT_facmo
+		lda  floats.AYINT_facmo+1
 		ldx  P8ZP_SCRATCH_REG
 		rts
 		.pend
@@ -165,9 +165,9 @@ stack_float2w	.proc               ; also used for float2b
 		stx  P8ZP_SCRATCH_REG
 		jsr  AYINT
 		ldx  P8ZP_SCRATCH_REG
-		lda  $64
+		lda  floats.AYINT_facmo
 		sta  P8ESTACK_HI,x
-		lda  $65
+		lda  floats.AYINT_facmo+1
 		sta  P8ESTACK_LO,x
 		dex
 		rts
@@ -1,10 +1,7 @@
 ; Prog8 definitions for floating point handling on the Commodore-64
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 %option enable_floats
+%import floats_functions

 floats {
 	; ---- this block contains C-64 floating point related functions ----
@@ -12,7 +9,6 @@ floats {
        const float  PI     = 3.141592653589793
        const float  TWOPI  = 6.283185307179586

-        float  tempvar_swap_float     ; used for some swap() operations

 ; ---- C64 basic and kernal ROM float constants and functions ----

@@ -91,7 +87,6 @@ romsub $e2b4 = TAN() clobbers(A,X,Y)                        ; fac1 = TAN(fac1)
 romsub $e30e = ATN() clobbers(A,X,Y)                        ; fac1 = ATN(fac1)


-
 asmsub  FREADS32() clobbers(A,X,Y)  {
 	; ---- fac1 = signed int32 from $62-$65 big endian (MSB FIRST)
 	%asm {{
@@ -174,42 +169,7 @@ asmsub  GETADRAY  () clobbers(X) -> uword @ AY  {
 	}}
 }

-sub  print_f  (float value) {
-	; ---- prints the floating point value (without a newline).
-	%asm {{
-		stx  floats_store_reg
-		lda  #<value
-		ldy  #>value
-		jsr  MOVFM		; load float into fac1
-		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		beq  +
-		jsr  c64.CHROUT
-		iny
-		bne  -
-+		ldx  floats_store_reg
-		rts
-	}}
-}
-
-sub pow(float value, float power) -> float {
-    %asm {{
-        phx
-        phy
-        lda  #<value
-        ldy  #>value
-        jsr  floats.CONUPK
-        lda  #<power
-        ldy  #>power
-        jsr  floats.FPWR
-        ply
-        plx
-        rts
-    }}
-}
+&uword AYINT_facmo = $64      ; $64/$65 contain result of AYINT

 %asminclude "library:c64/floats.asm"
 %asminclude "library:c64/floats_funcs.asm"
@@ -1,188 +1,6 @@
 ; --- floating point builtin functions


-abs_f_stack	.proc
-		; -- push abs(AY) on stack
-		jsr  floats.MOVFM
-		jsr  floats.ABS
-		jmp  push_fac1
-		.pend
-
-abs_f_fac1	.proc
-		; -- FAC1 = abs(AY)
-		jsr  floats.MOVFM
-		jmp  floats.ABS
-		.pend
-
-func_atan_stack	.proc
-		jsr  func_atan_fac1
-		jmp  push_fac1
-		.pend
-
-func_atan_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  ATN
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_ceil_stack	.proc
-		jsr  func_ceil_fac1
-		jmp  push_fac1
-		.pend
-
-func_ceil_fac1	.proc
-		; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		ldx  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  MOVMF
-		jsr  INT
-		lda  #<fmath_float1
-		ldy  #>fmath_float1
-		jsr  FCOMP
-		cmp  #0
-		beq  +
-		lda  #<FL_ONE_const
-		ldy  #>FL_ONE_const
-		jsr  FADD
-+		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_floor_stack	.proc
-		jsr  func_floor_fac1
-		jmp  push_fac1
-		.pend
-
-func_floor_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  INT
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_round_stack	.proc
-		jsr  func_round_fac1
-		jmp  push_fac1
-		.pend
-
-func_round_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  FADDH
-		jsr  INT
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_sin_stack	.proc
-		jsr  func_sin_fac1
-		jmp  push_fac1
-		.pend
-
-func_sin_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  SIN
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_cos_stack	.proc
-		jsr  func_cos_fac1
-		jmp  push_fac1
-		.pend
-
-func_cos_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  COS
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_tan_stack	.proc
-		jsr  func_tan_fac1
-		jmp  push_fac1
-		.pend
-
-func_tan_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  TAN
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_rad_stack	.proc
-		jsr  func_rad_fac1
-		jmp  push_fac1
-		.pend
-
-func_rad_fac1	.proc
-		; -- convert degrees to radians (d * pi / 180)
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		lda  #<_pi_div_180
-		ldy  #>_pi_div_180
-		jsr  FMULT
-		ldx  P8ZP_SCRATCH_REG
-		rts
-_pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
-		.pend
-
-func_deg_stack	.proc
-		jsr  func_deg_fac1
-		jmp  push_fac1
-		.pend
-
-func_deg_fac1	.proc
-		; -- convert radians to degrees (d * (1/ pi * 180))
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		lda  #<_one_over_pi_div_180
-		ldy  #>_one_over_pi_div_180
-		jsr  FMULT
-		ldx  P8ZP_SCRATCH_REG
-		rts
-_one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
-		.pend
-
-func_ln_stack	.proc
-		jsr  func_ln_fac1
-		jmp  push_fac1
-		.pend
-
-func_ln_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  LOG
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_log2_stack	.proc
-		jsr  func_log2_fac1
-		jmp  push_fac1
-		.pend
-
-func_log2_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  LOG
-		jsr  MOVEF
-		lda  #<FL_LOG2_const
-		ldy  #>FL_LOG2_const
-		jsr  MOVFM
-		jsr  FDIVT
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
 func_sign_f_stack	.proc
 		jsr  func_sign_f_into_A
 		sta  P8ESTACK_LO,x
@@ -195,33 +13,6 @@ func_sign_f_into_A	.proc
 		jmp  SIGN
 		.pend

-func_sqrt_stack	.proc
-		jsr  func_sqrt_fac1
-		jmp  push_fac1
-		.pend
-
-func_sqrt_fac1	.proc
-		jsr  MOVFM
-		stx  P8ZP_SCRATCH_REG
-		jsr  SQR
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
-func_rndf_stack	.proc
-		jsr  func_rndf_fac1
-		jmp  push_fac1
-		.pend
-
-func_rndf_fac1	.proc
-		stx  P8ZP_SCRATCH_REG
-		lda  #1
-		jsr  FREADSA
-		jsr  RND		; rng into fac1
-		ldx  P8ZP_SCRATCH_REG
-		rts
-		.pend
-
 func_swap_f	.proc
 		; -- swap floats pointed to by SCRATCH_ZPWORD1, SCRATCH_ZPWORD2
 		ldy  #4
@@ -353,85 +144,3 @@ func_all_f_stack	.proc
 		jsr  a_times_5
 		jmp  prog8_lib.func_all_b_stack
 		.pend
-
-func_max_f_stack	.proc
-		jsr  func_max_f_fac1
-		jmp  push_fac1
-		.pend
-
-func_max_f_fac1	.proc
-		; -- max(array) -> fac1,  array in P8ZP_SCRATCH_W1, num elts in A
-_loop_count = P8ZP_SCRATCH_REG
-		stx  floats_store_reg
-		sta  _loop_count
-		lda  #255
-		sta  _minmax_cmp+1		; modifying
-		lda  #<_largest_neg_float
-		ldy  #>_largest_neg_float
-_minmax_entry	jsr  MOVFM
-		lda  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  FCOMP
-_minmax_cmp	cmp  #255			; modified
-		bne  +
-		lda  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  MOVFM
-+		lda  P8ZP_SCRATCH_W1
-		clc
-		adc  #5
-		sta  P8ZP_SCRATCH_W1
-		bcc  +
-		inc  P8ZP_SCRATCH_W1+1
-+		dec  _loop_count
-		bne  -
-		ldx  floats_store_reg
-		rts
-_largest_neg_float	.byte 255,255,255,255,255		; largest negative float -1.7014118345e+38
-		.pend
-
-func_min_f_stack	.proc
-		jsr  func_min_f_fac1
-		jmp  push_fac1
-		.pend
-
-func_min_f_fac1	.proc
-		; -- min(array) -> fac1,  array in P8ZP_SCRATCH_W1, num elts in A
-		sta  func_max_f_fac1._loop_count
-		lda  #1
-		sta  func_max_f_fac1._minmax_cmp+1
-		lda  #<_largest_pos_float
-		ldy  #>_largest_pos_float
-		jmp  func_max_f_fac1._minmax_entry
-_largest_pos_float	.byte  255,127,255,255,255		; largest positive float
-		rts
-		.pend
-
-
-func_sum_f_stack	.proc
-		jsr  func_sum_f_fac1
-		jmp  push_fac1
-		.pend
-
-func_sum_f_fac1	.proc
-		; -- sum(array) -> fac1,  array in P8ZP_SCRATCH_W1, num elts in A
-_loop_count = P8ZP_SCRATCH_REG
-		stx  floats_store_reg
-		sta  _loop_count
-		lda  #<FL_ZERO_const
-		ldy  #>FL_ZERO_const
-		jsr  MOVFM
-		lda  P8ZP_SCRATCH_W1
-		ldy  P8ZP_SCRATCH_W1+1
-		jsr  FADD
-		lda  P8ZP_SCRATCH_W1
-		clc
-		adc  #5
-		sta  P8ZP_SCRATCH_W1
-		bcc  +
-		inc  P8ZP_SCRATCH_W1+1
-+		dec  _loop_count
-		bne  -
-		ldx  floats_store_reg
-		rts
-		.pend
@@ -38,8 +38,12 @@ graphics {

        if y1>y2 {
            ; make sure dy is always positive to have only 4 instead of 8 special cases
-            swap(x1, x2)
-            swap(y1, y2)
+            cx16.r0 = x1
+            x1 = x2
+            x2 = cx16.r0
+            cx16.r0L = y1
+            y1 = y2
+            y2 = cx16.r0L
        }
        word @zp dx = (x2 as word)-x1
        word @zp dy = (y2 as word)-y1
@@ -1,9 +1,5 @@
 ; Prog8 definitions for the Commodore-64
 ; Including memory registers, I/O registers, Basic and Kernal subroutines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 c64 {
        &ubyte  TIME_HI         = $a0       ; software jiffy clock, hi byte
@@ -300,6 +296,13 @@ asmsub  init_system_phase2()  {
    }}
 }

+asmsub  cleanup_at_exit() {
+    ; executed when the main subroutine does rts
+    %asm {{
+        jmp  c64.enable_runstop_and_charsetswitch
+    }}
+}
+
 asmsub  disable_runstop_and_charsetswitch() clobbers(A) {
    %asm {{
        lda  #$80
@@ -310,6 +313,16 @@ asmsub  disable_runstop_and_charsetswitch() clobbers(A) {
    }}
 }

+asmsub  enable_runstop_and_charsetswitch() clobbers(A) {
+    %asm {{
+        lda  #0
+        sta  657    ; enable charset switching
+        lda  #237
+        sta  808    ; enable run/stop key
+        rts
+    }}
+}
+
 asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	%asm {{
 	        sta  _modified+1
@@ -519,6 +532,17 @@ sys {
        }}
    }

+    asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
+        ; Called when the compiler wants to assign a string value to another string.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
        ; note: only works for NON-OVERLAPPING memory regions!
        ; note: can't be inlined because is called from asm as well
@@ -635,7 +659,10 @@ _longcopy
    inline asmsub exit(ubyte returnvalue @A) {
        ; -- immediately exit the program with a return code in the A register
        %asm {{
+            lda  #31
+            sta  $01        ; bank the kernal in
            jsr  c64.CLRCHN		; reset i/o channels
+            jsr  c64.enable_runstop_and_charsetswitch
            ldx  prog8_lib.orig_stackpointer
            txs
            rts		; return to original caller
@@ -658,6 +685,7 @@ cx16 {
    ; (because there's no room for them in the zeropage)
    ; they are allocated at the bottom of the eval-stack (should be ample space unless
    ; you're doing insane nesting of expressions...)
+    ; NOTE: the memory location of these registers can change based on the "-esa" compiler option
    &uword r0  = $cf00
    &uword r1  = $cf02
    &uword r2  = $cf04
@@ -1,8 +1,4 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the Commodore-64
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 %import syslib
 %import conv
@@ -1,7 +1,4 @@
 ; Number conversions routines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-

 conv {

@@ -267,7 +264,7 @@ inline asmsub  str2ubyte(str string @AY) clobbers(Y) -> ubyte @A {
 	}}
 }

-inline asmsub  str2byte(str string @AY) clobbers(Y) -> ubyte @A {
+inline asmsub  str2byte(str string @AY) clobbers(Y) -> byte @A {
 	; -- returns in A the signed byte value of the string number argument in AY
 	;    the number may be preceded by a + or - sign but may NOT contain spaces
 	;    (any non-digit character will terminate the number string that is parsed)
@@ -419,6 +416,9 @@ _loop
 	beq  _stop
 	cmp  #7                 ; screencode letters A-F are 1-6
 	bcc  _add_letter
+	and  #127
+	cmp  #97
+	bcs  _try_iso            ; maybe letter is iso:'a'-iso:'f' (97-102)
 	cmp  #'g'
 	bcs  _stop
 	cmp  #'a'
@@ -454,6 +454,11 @@ _add_letter
 	sta  P8ZP_SCRATCH_B1
 	pla
 	jmp  _calc
+_try_iso
+        cmp  #103
+        bcs  _stop
+        and  #63
+        bne  _add_letter
 	}}
 }

@@ -1,6 +1,4 @@
 ; Cx16 specific disk drive I/O routines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 %import diskio

@@ -73,4 +71,102 @@ cx16diskio {
        }}
    }

+
+    ; replacement function that makes use of fast block read capability of the X16
+    ; use this in place of regular diskio.f_read()
+    sub f_read(uword bufferpointer, uword num_bytes) -> uword {
+        ; -- read from the currently open file, up to the given number of bytes.
+        ;    returns the actual number of bytes read.  (checks for End-of-file and error conditions)
+        if not diskio.iteration_in_progress or not num_bytes
+            return 0
+
+        diskio.list_blocks = 0     ; we reuse this variable for the total number of bytes read
+        if diskio.have_first_byte {
+            diskio.have_first_byte=false
+            @(bufferpointer) = diskio.first_byte
+            bufferpointer++
+            diskio.list_blocks++
+            num_bytes--
+        }
+
+        void c64.CHKIN(11)        ; use #11 as input channel again
+
+        ; commander X16 supports fast block-read via macptr() kernal call
+        uword size
+        while num_bytes {
+            size = 255
+            if num_bytes<size
+                size = num_bytes
+            size = cx16.macptr(lsb(size), bufferpointer)
+            if_cs
+                goto byte_read_loop     ; macptr block read not supported, do fallback loop
+            diskio.list_blocks += size
+            bufferpointer += size
+            if msb(bufferpointer) == $c0
+                bufferpointer = mkword($a0, lsb(bufferpointer))  ; wrap over bank boundary
+            num_bytes -= size
+            if c64.READST() & $40 {
+                diskio.f_close()       ; end of file, close it
+                break
+            }
+        }
+        return diskio.list_blocks  ; number of bytes read
+
+byte_read_loop:         ; fallback if macptr() isn't supported on the device
+        %asm {{
+            lda  bufferpointer
+            sta  m_in_buffer+1
+            lda  bufferpointer+1
+            sta  m_in_buffer+2
+        }}
+        repeat num_bytes {
+            %asm {{
+                jsr  c64.CHRIN
+                sta  cx16.r5
+m_in_buffer     sta  $ffff
+                inc  m_in_buffer+1
+                bne  +
+                inc  m_in_buffer+2
+               inc  diskio.list_blocks
+                bne  +
+                inc  diskio.list_blocks+1
+
+            }}
+
+            if cx16.r5==$0d {   ; chance on I/o error status?
+                diskio.first_byte = c64.READST()
+                if diskio.first_byte & $40 {
+                    diskio.f_close()       ; end of file, close it
+                    diskio.list_blocks--   ; don't count that last CHRIN read
+                }
+                if diskio.first_byte
+                    return diskio.list_blocks  ; number of bytes read
+            }
+        }
+        return diskio.list_blocks  ; number of bytes read
+    }
+
+    ; replacement function that makes use of fast block read capability of the X16
+    ; use this in place of regular diskio.f_read_all()
+    sub f_read_all(uword bufferpointer) -> uword {
+        ; -- read the full contents of the file, returns number of bytes read.
+        if not diskio.iteration_in_progress
+            return 0
+
+        uword total_read = 0
+        if diskio.have_first_byte {
+            diskio.have_first_byte=false
+            @(bufferpointer) = diskio.first_byte
+            bufferpointer++
+            total_read = 1
+        }
+
+        while not c64.READST() {
+            uword size = cx16diskio.f_read(bufferpointer, 256)
+            total_read += size
+            bufferpointer += size
+        }
+        return total_read
+    }
+
 }
@@ -1,10 +1,7 @@
 ; Prog8 definitions for floating point handling on the CommanderX16
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 %option enable_floats
+%import floats_functions

 floats {
 	; ---- this block contains C-64 compatible floating point related functions ----
@@ -110,7 +107,6 @@ asmsub  GIVUAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	}}
 }

-
 asmsub  GIVAYFAY  (uword value @ AY) clobbers(A,X,Y)  {
 	; ---- signed 16 bit word in A/Y (lo/hi) to float in fac1
 	%asm {{
@@ -151,7 +147,6 @@ asmsub  FREADUY (ubyte value @Y) {
    }}
 }

-
 asmsub  RND() clobbers(A,X,Y) {
    %asm {{
        lda  #0
@@ -162,43 +157,7 @@ asmsub  RND() clobbers(A,X,Y) {
    }}
 }

-
-sub  print_f  (float value) {
-	; ---- prints the floating point value (without a newline).
-	%asm {{
-		phx
-		lda  #<value
-		ldy  #>value
-		jsr  MOVFM		; load float into fac1
-		jsr  FOUT		; fac1 to string in A/Y
-		sta  P8ZP_SCRATCH_W1
-		sty  P8ZP_SCRATCH_W1+1
-		ldy  #0
-		lda  (P8ZP_SCRATCH_W1),y
-		beq  +
-		jsr  c64.CHROUT
-		iny
-		bne  -
-+		plx
-		rts
-	}}
-}
-
-sub pow(float value, float power) -> float {
-    %asm {{
-        phx
-        phy
-        lda  #<value
-        ldy  #>value
-        jsr  floats.CONUPK
-        lda  #<power
-        ldy  #>power
-        jsr  floats.FPWR
-        ply
-        plx
-        rts
-    }}
-}
+&uword AYINT_facmo = $c6      ; $c6/$c7 contain result of AYINT

 %asminclude "library:c64/floats.asm"
 %asminclude "library:c64/floats_funcs.asm"
@@ -15,14 +15,12 @@
 ;   mode 1 = bitmap 320 x 240 monochrome
 ;   mode 2 = bitmap 320 x 240 x 4c (TODO not yet implemented)
 ;   mode 3 = bitmap 320 x 240 x 16c (TODO not yet implemented)
-;   mode 4 = bitmap 320 x 240 x 256c
+;   mode 4 = bitmap 320 x 240 x 256c  (like SCREEN $80 but using this api instead of kernal)
 ;   mode 5 = bitmap 640 x 480 monochrome
 ;   mode 6 = bitmap 640 x 480 x 4c
 ;   higher color dephts in highres are not supported due to lack of VRAM


-; TODO can we make a FB vector table and emulation routines for the Cx16s' GRAPH_init() call? to replace the builtin 320x200 fb driver?
-
 gfx2 {

    ; read-only control variables:
@@ -30,7 +28,7 @@ gfx2 {
    uword width = 0
    uword height = 0
    ubyte bpp = 0
-    ubyte monochrome_dont_stipple_flag = false            ; set to false to enable stippling mode in monochrome displaymodes
+    bool monochrome_dont_stipple_flag = false            ; set to false to enable stippling mode in monochrome displaymodes

    sub screen_mode(ubyte mode) {
        when mode {
@@ -129,28 +127,28 @@ gfx2 {
        position(0, 0)
    }

-    sub monochrome_stipple(ubyte enable) {
+    sub monochrome_stipple(bool enable) {
        monochrome_dont_stipple_flag = not enable
    }

-    sub rect(uword x, uword y, uword width, uword height, ubyte color) {
-        if width==0 or height==0
+    sub rect(uword x, uword y, uword rwidth, uword rheight, ubyte color) {
+        if rwidth==0 or rheight==0
            return
-        horizontal_line(x, y, width, color)
-        if height==1
+        horizontal_line(x, y, rwidth, color)
+        if rheight==1
            return
-        horizontal_line(x, y+height-1, width, color)
-        vertical_line(x, y+1, height-2, color)
-        if width==1
+        horizontal_line(x, y+rheight-1, rwidth, color)
+        vertical_line(x, y+1, rheight-2, color)
+        if rwidth==1
            return
-        vertical_line(x+width-1, y+1, height-2, color)
+        vertical_line(x+rwidth-1, y+1, rheight-2, color)
    }

-    sub fillrect(uword x, uword y, uword width, uword height, ubyte color) {
-        if width==0
+    sub fillrect(uword x, uword y, uword rwidth, uword rheight, ubyte color) {
+        if rwidth==0
            return
-        repeat height {
-            horizontal_line(x, y, width, color)
+        repeat rheight {
+            horizontal_line(x, y, rwidth, color)
            y++
        }
    }
@@ -290,7 +288,7 @@ _done
        }
    }

-    sub vertical_line(uword x, uword y, uword height, ubyte color) {
+    sub vertical_line(uword x, uword y, uword lheight, ubyte color) {
        when active_mode {
            1, 5 -> {
                ; monochrome, lo-res
@@ -303,7 +301,7 @@ _done
                            set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
                        else
                            set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
-                        repeat height {
+                        repeat lheight {
                            %asm {{
                                lda  cx16.VERA_DATA0
                                ora  cx16.r15L
@@ -314,14 +312,14 @@ _done
                        ; draw stippled line.
                        if x&1 {
                            y++
-                            height--
+                            lheight--
                        }
                        position2(x,y,true)
                        if active_mode==1
                            set_both_strides(12)    ; 80 increment = 2 line in 320 px monochrome
                        else
                            set_both_strides(13)    ; 160 increment = 2 line in 640 px monochrome
-                        repeat height/2 {
+                        repeat lheight/2 {
                            %asm {{
                                lda  cx16.VERA_DATA0
                                ora  cx16.r15L
@@ -336,7 +334,7 @@ _done
                        set_both_strides(11)    ; 40 increment = 1 line in 320 px monochrome
                    else
                        set_both_strides(12)    ; 80 increment = 1 line in 640 px monochrome
-                    repeat height {
+                    repeat lheight {
                        %asm {{
                            lda  cx16.VERA_DATA0
                            and  cx16.r15L
@@ -351,7 +349,7 @@ _done
                position(x,y)
                cx16.VERA_ADDR_H = cx16.VERA_ADDR_H & %00000111 | (14<<4)
                %asm {{
-                    ldy  height
+                    ldy  lheight
                    beq  +
                    lda  color
 -                   sta  cx16.VERA_DATA0
@@ -363,14 +361,14 @@ _done
            6 -> {
                ; highres 4c
                ; use TWO vera adress pointers simultaneously one for reading, one for writing, so auto-increment is possible
-                if height==0
+                if lheight==0
                    return
                position2(x,y,true)
                set_both_strides(13)    ; 160 increment = 1 line in 640 px 4c mode
                color &= 3
                color <<= gfx2.plot.shift4c[lsb(x) & 3]
                ubyte @shared mask = gfx2.plot.mask4c[lsb(x) & 3]
-                repeat height {
+                repeat lheight {
                    %asm {{
                        lda  cx16.VERA_DATA0
                        and  mask
@@ -396,8 +394,12 @@ _done
        ; This code special-cases various quadrant loops to allow simple ++ and -- operations.
        if y1>y2 {
            ; make sure dy is always positive to have only 4 instead of 8 special cases
-            swap(x1, x2)
-            swap(y1, y2)
+            cx16.r0 = x1
+            x1 = x2
+            x2 = cx16.r0
+            cx16.r0 = y1
+            y1 = y2
+            y2 = cx16.r0
        }
        word @zp dx = (x2 as word)-x1
        word @zp dy = (y2 as word)-y1
@@ -681,7 +683,7 @@ _done
        }
    }

-    sub position2(uword @zp x, uword y, ubyte also_port_1) {
+    sub position2(uword @zp x, uword y, bool also_port_1) {
        position(x, y)
        if also_port_1 {
            when active_mode {
@@ -2,15 +2,20 @@
 %import textio

 ; Bitmap pixel graphics module for the CommanderX16
-; wraps the graphics functions that are in ROM.
-; only black/white monochrome 320x200 for now. (i.e. truncated at the bottom)
-; For full-screen 640x480 or 320x240 graphics, use the "gfx2" module instead. (but that is Cx16-specific)
+; Wraps the graphics functions that are in ROM.
+; Only lo-res 320x240 256 color mode for now.
+; Unlike graphics module on the C64, you can use colors() to set new drawing colors for every draw operation.
+; For other resolutions or other color modes, use the "gfx2" module instead. (which is Cx16-specific)
 ; Note: there is no color palette manipulation here, you have to do that yourself or use the "palette" module.


 graphics {
    const uword WIDTH = 320
-    const ubyte HEIGHT = 200
+    const ubyte HEIGHT = 240
+
+
+    ubyte stroke_color = 1
+    ubyte background_color = 0

    sub enable_bitmap_mode() {
        ; enable bitmap screen, erase it and set colors to black/white.
@@ -27,10 +32,18 @@ graphics {


    sub clear_screen(ubyte pixelcolor, ubyte bgcolor) {
+        stroke_color = pixelcolor
+        background_color = bgcolor
        cx16.GRAPH_set_colors(pixelcolor, pixelcolor, bgcolor)
        cx16.GRAPH_clear()
    }

+    sub colors(ubyte stroke, ubyte fill) {
+        ; this routine is only available on the cx16, other targets can't change colors on the fly
+        cx16.GRAPH_set_colors(stroke, fill, background_color)
+        stroke_color = stroke
+    }
+
    sub line(uword @zp x1, ubyte @zp y1, uword @zp x2, ubyte @zp y2) {
        cx16.GRAPH_draw_line(x1, y1, x2, y2)
    }
@@ -71,31 +84,31 @@ graphics {
            cx16.r0 = xcenter + xx
            cx16.r1 = ycenter + yy
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter - xx
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter + xx
            cx16.r1 = ycenter - yy
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter - xx
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter + yy
            cx16.r1 = ycenter + xx
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter - yy
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter + yy
            cx16.r1 = ycenter - xx
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            cx16.r0 = xcenter - yy
            cx16.FB_cursor_position2()
-            cx16.FB_set_pixel(1)
+            cx16.FB_set_pixel(stroke_color)
            yy++
            if decisionOver2<=0 {
                decisionOver2 += (yy as word)*2+1
@@ -13,20 +13,20 @@ palette {
        cx16.vpoke(1, vera_palette_ptr, msb(color))
    }

-    sub set_rgb4(uword palette_bytes_ptr, uword num_colors) {
-        ; 2 bytes per color entry, the Vera uses this, but the R/GB bytes order is swapped
+    sub set_rgb_be(uword palette_ptr, uword num_colors) {
+        ; 1 word per color entry, $0rgb in big endian format
        vera_palette_ptr = $fa00
        repeat num_colors {
-            cx16.vpoke(1, vera_palette_ptr+1, @(palette_bytes_ptr))
-            palette_bytes_ptr++
-            cx16.vpoke(1, vera_palette_ptr, @(palette_bytes_ptr))
-            palette_bytes_ptr++
+            cx16.vpoke(1, vera_palette_ptr+1, @(palette_ptr))
+            palette_ptr++
+            cx16.vpoke(1, vera_palette_ptr, @(palette_ptr))
+            palette_ptr++
            vera_palette_ptr+=2
        }
    }

    sub set_rgb(uword palette_words_ptr, uword num_colors) {
-        ; 1 word per color entry (in little endian format so $gb0r)
+        ; 1 word per color entry (in little endian format as layed out in video memory, so $gb0r)
        vera_palette_ptr = $fa00
        repeat num_colors*2 {
            cx16.vpoke(1, vera_palette_ptr, @(palette_words_ptr))
@@ -0,0 +1,157 @@
+%import syslib
+
+psg {
+    ; $1F9C0 - $1F9FF 	16 blocks of 4 PSG registers (16 voices)
+    ; 00  frequency word LSB
+    ; 01  frequency word MSB.    freqword = HERZ / 0.3725290298461914
+    ; 02  bit 7 =right, bit 6 = left, bits 5-0 = volume 0-63 levels
+    ; 03  bit 7,6 = waveform, bits 5-0 = Pulse width 0-63
+    ; waveform: 0=pulse, 1=sawtooth, 2=triangle, 3=noise
+    const ubyte PULSE    = %00000000
+    const ubyte SAWTOOTH = %01000000
+    const ubyte TRIANGLE = %10000000
+    const ubyte NOISE    = %11000000
+    const ubyte LEFT     = %01000000
+    const ubyte RIGHT    = %10000000
+
+    sub voice(ubyte voice_num, ubyte channel, ubyte volume, ubyte waveform, ubyte pulsewidth) {
+        envelope_states[voice_num] = 255
+        cx16.r0 = $f9c2 + voice_num * 4
+        cx16.VERA_CTRL = 0
+        cx16.VERA_ADDR_L = lsb(cx16.r0)
+        cx16.VERA_ADDR_M = msb(cx16.r0)
+        cx16.VERA_ADDR_H = 1
+        cx16.VERA_DATA0 = channel | volume
+        cx16.VERA_ADDR_L++
+        cx16.VERA_DATA0 = waveform | pulsewidth
+        envelope_volumes[voice_num] = mkword(volume, 0)
+        envelope_maxvolumes[voice_num] = volume
+    }
+
+;    sub freq_hz(ubyte voice_num, float hertz) {
+;        ; this would rely on floating point math to convert hertz to vera frequency
+;        ; TODO should be replaced by integer math maybe with a lookup table?
+;        uword vera_freq = (hertz / 0.3725290298461914) as uword
+;        freq(voice_num, vera_freq)
+;    }
+
+    sub freq(ubyte voice_num, uword vera_freq) {
+        cx16.r0 = $f9c0 + voice_num * 4
+        cx16.VERA_CTRL = 0
+        cx16.VERA_ADDR_L = lsb(cx16.r0)
+        cx16.VERA_ADDR_M = msb(cx16.r0)
+        cx16.VERA_ADDR_H = 1
+        cx16.VERA_DATA0 = lsb(vera_freq)
+        cx16.VERA_ADDR_L++
+        cx16.VERA_DATA0 = msb(vera_freq)
+    }
+
+    sub volume(ubyte voice_num, ubyte vol) {
+        cx16.r0 = $f9c2 + voice_num * 4
+        cx16.vpoke(1, cx16.r0, cx16.vpeek(1, cx16.r0) & %11000000 | vol)
+        envelope_volumes[voice_num] = mkword(vol, 0)
+        envelope_maxvolumes[voice_num] = vol
+    }
+
+    sub pulse_width(ubyte voice_num, ubyte pw) {
+        cx16.r0 = $f9c3 + voice_num * 4
+        cx16.vpoke(1, cx16.r0, cx16.vpeek(1, cx16.r0) & %11000000 | pw)
+    }
+
+    sub envelope(ubyte voice_num, ubyte maxvolume, ubyte attack, ubyte sustain, ubyte release) {
+        envelope_states[voice_num] = 255
+        envelope_attacks[voice_num] = attack
+        envelope_sustains[voice_num] = sustain
+        envelope_releases[voice_num] = release
+        if attack
+            attack = 0
+        else
+            attack = maxvolume     ; max volume when no attack is set
+        envelope_volumes[voice_num] = mkword(attack, 0)
+        envelope_maxvolumes[voice_num] = maxvolume
+        envelope_states[voice_num] = 0
+    }
+
+    sub silent() {
+        for cx16.r1L in 0 to 15 {
+            envelope_states[cx16.r1L] = 255
+            envelope_volumes[cx16.r1L] = 0
+            volume(cx16.r1L, 0)
+        }
+    }
+
+    sub envelopes_irq() {
+        ; If you want to use real-time volume envelopes (Attack-Sustain-Release),
+        ; you have to call this routine every 1/60th second, for example from your vsync irq handler,
+        ; or just install this routine as the only irq handler if you don't have to do other things there.
+        ; Example: cx16.set_irq(&psg.envelopes_irq, true)
+
+        ; cx16.r0 = the volume word (volume scaled by 256)
+        ; cx16.r1L = the voice number
+        ; cx16.r2L = attack value
+
+        pushw(cx16.r0)
+        push(cx16.r1L)
+        push(cx16.r2L)
+        pushw(cx16.r9)
+        ; calculate new volumes
+        for cx16.r1L in 0 to 15 {
+            when envelope_states[cx16.r1L] {
+                0 -> {
+                    ; attack
+                    cx16.r2L = envelope_maxvolumes[cx16.r1L]
+                    cx16.r0 = envelope_volumes[cx16.r1L] + envelope_attacks[cx16.r1L] * $0040
+                    if msb(cx16.r0) > cx16.r2L or envelope_attacks[cx16.r1L]==0 {
+                        cx16.r0 = mkword(cx16.r2L, 0)
+                        envelope_attacks[cx16.r1L] = 0
+                        envelope_states[cx16.r1L] = 1  ; start sustain
+                    }
+                    envelope_volumes[cx16.r1L] = cx16.r0
+                }
+                1 -> {
+                    ; sustain
+                    if envelope_sustains[cx16.r1L] {
+                        envelope_sustains[cx16.r1L]--
+                    } else {
+                        envelope_states[cx16.r1L] = 2  ; start release
+                    }
+                }
+                2 -> {
+                    ; release
+                    cx16.r0 = envelope_volumes[cx16.r1L] - envelope_releases[cx16.r1L] * $0040
+                    if msb(cx16.r0) & %11000000 {
+                        cx16.r0 = 0
+                        envelope_releases[cx16.r1L] = 0
+                    }
+                    envelope_volumes[cx16.r1L] = cx16.r0
+                }
+            }
+        }
+
+        ; set new volumes of all 16 voices, using vera stride of 4
+        cx16.push_vera_context()
+        cx16.VERA_CTRL = 0
+        cx16.VERA_ADDR_L = $c2
+        cx16.VERA_ADDR_M = $f9
+        cx16.VERA_ADDR_H = 1 | %00110000
+        cx16.VERA_CTRL = 1
+        cx16.VERA_ADDR_L = $c2
+        cx16.VERA_ADDR_M = $f9
+        cx16.VERA_ADDR_H = 1 | %00110000
+        for cx16.r1L in 0 to 15 {
+            cx16.VERA_DATA0 = cx16.VERA_DATA1 & %11000000 | msb(envelope_volumes[cx16.r1L])
+        }
+        cx16.pop_vera_context()
+        popw(cx16.r9)
+        pop(cx16.r2L)
+        pop(cx16.r1L)
+        popw(cx16.r0)
+    }
+
+    ubyte[16] envelope_states
+    uword[16] envelope_volumes      ; scaled by 256
+    ubyte[16] envelope_attacks
+    ubyte[16] envelope_sustains
+    ubyte[16] envelope_releases
+    ubyte[16] envelope_maxvolumes
+}
@@ -1,9 +1,5 @@
 ; Prog8 definitions for the CommanderX16
 ; Including memory registers, I/O registers, Basic and Kernal subroutines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 c64 {

@@ -367,7 +363,7 @@ romsub $fed5 = console_set_paging_message(uword msgptr @R0)  clobbers(A,X,Y)
 romsub $fecf = entropy_get() -> ubyte @A, ubyte @X, ubyte @Y
 romsub $fecc = monitor()  clobbers(A,X,Y)

-romsub $ff44 = macptr()  clobbers(A,X,Y)
+romsub $ff44 = macptr(ubyte length @A, uword buffer @XY)  clobbers(A) -> ubyte @Pc, uword @XY
 romsub $ff47 = enter_basic(ubyte cold_or_warm @Pc)  clobbers(A,X,Y)
 romsub $ff4d = clock_set_date_time(uword yearmonth @R0, uword dayhours @R1, uword minsecs @R2, ubyte jiffies @R3)  clobbers(A, X, Y)
 romsub $ff50 = clock_get_date_time()  clobbers(A, X, Y)  -> uword @R0, uword @R1, uword @R2, ubyte @R3   ; result registers see clock_set_date_time()
@@ -415,28 +411,28 @@ asmsub mouse_pos() -> ubyte @A {
 inline asmsub rombank(ubyte bank @A) {
    ; -- set the rom banks
    %asm {{
-        sta  $01            ; rom bank register (v39+, used to be cx16.d1prb $9f60 in v38)
+        sta  $01
    }}
 }

 inline asmsub rambank(ubyte bank @A) {
    ; -- set the ram bank
    %asm {{
-        sta  $00            ; ram bank register (v39+, used to be cx16.d1pra $9f61 in v38)
+        sta  $00
    }}
 }

 inline asmsub getrombank() -> ubyte @A {
    ; -- get the current rom bank
    %asm {{
-        lda  $01            ; rom bank register (v39+, used to be cx16.d1prb $9f60 in v38)
+        lda  $01
    }}
 }

 inline asmsub getrambank() -> ubyte @A {
    ; -- get the current ram bank
    %asm {{
-        lda  $00            ; ram bank register (v39+, used to be cx16.d1pra $9f61 in v38)
+        lda  $00
    }}
 }

@@ -641,6 +637,18 @@ asmsub  init_system_phase2()  {
    }}
 }

+asmsub  cleanup_at_exit() {
+    ; executed when the main subroutine does rts
+    %asm {{
+        lda  #1
+        sta  $00        ; ram bank 1
+        lda  #4
+        sta  $01        ; rom bank 4 (kernal)
+        stz  $2d        ; hack to reset machine code monitor bank to 0
+        rts
+    }}
+}
+
 asmsub  set_irq(uword handler @AY, ubyte useKernal @Pc) clobbers(A)  {
 	%asm {{
 	        sta  _modified+1
@@ -727,6 +735,56 @@ IRQ_SCRATCH_ZPWORD2	.word  0
 		}}
 }

+asmsub push_vera_context() clobbers(A) {
+    ; -- use this at the start of your IRQ handler if it uses Vera registers, to save the state
+    %asm {{
+        ; note cannot store this on cpu hardware stack because this gets called as a subroutine
+        lda  cx16.VERA_ADDR_L
+        sta  _vera_storage
+        lda  cx16.VERA_ADDR_M
+        sta  _vera_storage+1
+        lda  cx16.VERA_ADDR_H
+        sta  _vera_storage+2
+        lda  cx16.VERA_CTRL
+        sta  _vera_storage+3
+        eor  #1
+        sta  cx16.VERA_CTRL
+        lda  cx16.VERA_ADDR_L
+        sta  _vera_storage+4
+        lda  cx16.VERA_ADDR_M
+        sta  _vera_storage+5
+        lda  cx16.VERA_ADDR_H
+        sta  _vera_storage+6
+        lda  cx16.VERA_CTRL
+        sta  _vera_storage+7
+        rts
+_vera_storage:  .byte 0,0,0,0,0,0,0,0
+    }}
+}
+
+asmsub pop_vera_context() clobbers(A) {
+    ; -- use this at the end of your IRQ handler if it uses Vera registers, to restore the state
+    %asm {{
+        lda  cx16.push_vera_context._vera_storage+7
+        sta  cx16.VERA_CTRL
+        lda  cx16.push_vera_context._vera_storage+6
+        sta  cx16.VERA_ADDR_H
+        lda  cx16.push_vera_context._vera_storage+5
+        sta  cx16.VERA_ADDR_M
+        lda  cx16.push_vera_context._vera_storage+4
+        sta  cx16.VERA_ADDR_L
+        lda  cx16.push_vera_context._vera_storage+3
+        sta  cx16.VERA_CTRL
+        lda  cx16.push_vera_context._vera_storage+2
+        sta  cx16.VERA_ADDR_H
+        lda  cx16.push_vera_context._vera_storage+1
+        sta  cx16.VERA_ADDR_M
+        lda  cx16.push_vera_context._vera_storage+0
+        sta  cx16.VERA_ADDR_L
+        rts
+    }}
+}
+

 asmsub  restore_irq() clobbers(A) {
 	%asm {{
@@ -810,7 +868,9 @@ sys {
        ; Soft-reset the system back to initial power-on Basic prompt.
        %asm {{
            sei
-            stz  $01            ; bank the kernal in
+            stz  $01                        ; bank the kernal in
+            lda  #$80
+            sta  cx16.VERA_CTRL             ; reset Vera (kernal doesn't do this?)
            jmp  (cx16.RESET_VEC)
        }}
    }
@@ -840,6 +900,17 @@ sys {
        }}
    }

+    asmsub internal_stringcopy(uword source @R0, uword target @AY) clobbers (A,Y) {
+        ; Called when the compiler wants to assign a string value to another string.
+        %asm {{
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		lda  cx16.r0
+		ldy  cx16.r0+1
+		jmp  prog8_lib.strcpy
+        }}
+    }
+
    asmsub memcopy(uword source @R0, uword target @R1, uword count @AY) clobbers(A,X,Y) {
        ; note: only works for NON-OVERLAPPING memory regions!
        ;       If you have to copy overlapping memory regions, consider using
@@ -1,8 +1,4 @@
 ; Prog8 definitions for the Text I/O and Screen routines for the CommanderX16
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
-; indent format: TABS, size=8

 %import syslib
 %import conv
@@ -195,7 +191,7 @@ sub iso_off() {


 asmsub  scroll_left() clobbers(A, Y)  {
-	; ---- scroll the whole screen 1 character to the left   TODO optimize this more?
+	; ---- scroll the whole screen 1 character to the left
 	;      contents of the rightmost column are unchanged, you should clear/refill this yourself
 	%asm {{
 	    phx
@@ -241,7 +237,7 @@ _lx     ldx  #0                ; modified
 }

 asmsub  scroll_right() clobbers(A)  {
-	; ---- scroll the whole screen 1 character to the right  TODO optimize this more?
+	; ---- scroll the whole screen 1 character to the right
 	;      contents of the leftmost column are unchanged, you should clear/refill this yourself
 	%asm {{
 	    phx
@@ -295,7 +291,7 @@ _lx     ldx  #0                 ; modified
 }

 asmsub  scroll_up() clobbers(A, Y)  {
-	; ---- scroll the whole screen 1 character up   TODO optimize this more?
+	; ---- scroll the whole screen 1 character up
 	;      contents of the bottom row are unchanged, you should refill/clear this yourself
 	%asm {{
 	    phx
@@ -345,7 +341,7 @@ _nextline
 }

 asmsub  scroll_down() clobbers(A, Y)  {
-	; ---- scroll the whole screen 1 character down     TODO optimize this more?
+	; ---- scroll the whole screen 1 character down
 	;      contents of the top row are unchanged, you should refill/clear this yourself
 	%asm {{
 	    phx
@@ -635,7 +631,7 @@ asmsub  setchr  (ubyte col @X, ubyte row @Y, ubyte character @A) clobbers(A)  {
            asl  a
            sta  cx16.VERA_ADDR_L
            tya
-            clc
+            ; clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            pla
@@ -655,7 +651,7 @@ asmsub  getchr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
            pla
            sta  cx16.VERA_ADDR_L
            tya
-            clc
+            ; clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            lda  cx16.VERA_DATA0
@@ -677,7 +673,7 @@ asmsub  setclr  (ubyte col @X, ubyte row @Y, ubyte color @A) clobbers(A)  {
            ina
            sta  cx16.VERA_ADDR_L
            tya
-            clc
+            ; clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            pla
@@ -698,7 +694,7 @@ asmsub  getclr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
            pla
            sta  cx16.VERA_ADDR_L
            tya
-            clc
+            ; clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            lda  cx16.VERA_DATA0
@@ -707,36 +703,29 @@ asmsub  getclr  (ubyte col @A, ubyte row @Y) -> ubyte @ A {
 }

 sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
-	; ---- set char+color at the given position on the screen  TODO optimize this better
-	;      note: color handling is the same as on the C64: it only sets the foreground color.
-	;            use setcc2 if you want Cx-16 specific feature of setting both Bg+Fg colors.
+	; ---- set char+color at the given position on the screen
+	;      note: color handling is the same as on the C64: it only sets the foreground color and leaves the background color as is.
+	;            Use setcc2 if you want Cx-16 specific feature of setting both Bg+Fg colors (is faster as well).
 	%asm {{
            phx
            lda  column
            asl  a
            tax
            ldy  row
-            lda  charcolor
-            and  #$0f
-            sta  P8ZP_SCRATCH_B1
            stz  cx16.VERA_CTRL
            lda  #VERA_TEXTMATRIX_BANK
            sta  cx16.VERA_ADDR_H
            stx  cx16.VERA_ADDR_L
            tya
-            clc
+            ;clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            lda  char
            sta  cx16.VERA_DATA0
-            inx
-            lda  #VERA_TEXTMATRIX_BANK
-            sta  cx16.VERA_ADDR_H
-            stx  cx16.VERA_ADDR_L
-            tya
-            clc
-            adc  #>VERA_TEXTMATRIX_ADDR
-            sta  cx16.VERA_ADDR_M
+            inc  cx16.VERA_ADDR_L
+            lda  charcolor
+            and  #$0f
+            sta  P8ZP_SCRATCH_B1
            lda  cx16.VERA_DATA0
            and  #$f0
            ora  P8ZP_SCRATCH_B1
@@ -747,9 +736,9 @@ sub  setcc  (ubyte column, ubyte row, ubyte char, ubyte charcolor)  {
 }

 sub  setcc2  (ubyte column, ubyte row, ubyte char, ubyte colors)  {
-	; ---- set char+color at the given position on the screen  TODO optimize this
+	; ---- set char+color at the given position on the screen
 	;      note: on the CommanderX16 this allows you to set both Fg and Bg colors;
-	;            use the high nybble in A to set the Bg color!
+	;            use the high nybble in A to set the Bg color! Is a bit faster than setcc() too.
 	%asm {{
            phx
            lda  column
@@ -761,19 +750,12 @@ sub  setcc2  (ubyte column, ubyte row, ubyte char, ubyte colors)  {
            sta  cx16.VERA_ADDR_H
            stx  cx16.VERA_ADDR_L
            tya
-            clc
+            ; clc
            adc  #>VERA_TEXTMATRIX_ADDR
            sta  cx16.VERA_ADDR_M
            lda  char
            sta  cx16.VERA_DATA0
-            inx
-            lda  #VERA_TEXTMATRIX_BANK
-            sta  cx16.VERA_ADDR_H
-            stx  cx16.VERA_ADDR_L
-            tya
-            clc
-            adc  #>VERA_TEXTMATRIX_ADDR
-            sta  cx16.VERA_ADDR_M
+            inc  cx16.VERA_ADDR_L
            lda  colors
            sta  cx16.VERA_DATA0
            plx
@@ -1,6 +1,4 @@
 ; C64 and Cx16 disk drive I/O routines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 %import textio
 %import string
@@ -8,7 +6,7 @@

 diskio {

-    sub directory(ubyte drivenumber) -> ubyte {
+    sub directory(ubyte drivenumber) -> bool {
        ; -- Prints the directory contents of disk drive 8-11 to the screen. Returns success.

        c64.SETNAM(1, "$")
@@ -63,12 +61,12 @@ io_error:


    ; internal variables for the iterative file lister / loader
-    ubyte list_skip_disk_name
+    bool list_skip_disk_name
    uword list_pattern
    uword list_blocks
-    ubyte iteration_in_progress = false
+    bool iteration_in_progress = false
    ubyte @zp first_byte
-    ubyte have_first_byte
+    bool have_first_byte
    str   list_filename = "?" * 32


@@ -100,7 +98,7 @@ io_error:

    ; ----- iterative file lister functions (uses io channel 12) -----

-    sub lf_start_list(ubyte drivenumber, uword pattern_ptr) -> ubyte {
+    sub lf_start_list(ubyte drivenumber, uword pattern_ptr) -> bool {
        ; -- start an iterative file listing with optional pattern matching.
        ;    note: only a single iteration loop can be active at a time!
        lf_end_list()
@@ -129,7 +127,7 @@ io_error:
        return false
    }

-    sub lf_next_entry() -> ubyte {
+    sub lf_next_entry() -> bool {
        ; -- retrieve the next entry from an iterative file listing session.
        ;    results will be found in list_blocks and list_filename.
        ;    if it returns false though, there are no more entries (or an error occurred).
@@ -201,7 +199,7 @@ close_end:

    ; ----- iterative file loader functions (uses io channel 11) -----

-    sub f_open(ubyte drivenumber, uword filenameptr) -> ubyte {
+    sub f_open(ubyte drivenumber, uword filenameptr) -> bool {
        ; -- open a file for iterative reading with f_read
        ;    note: only a single iteration loop can be active at a time!
        f_close()
@@ -210,14 +208,16 @@ close_end:
        c64.SETLFS(11, drivenumber, 0)
        void c64.OPEN()          ; open 11,8,0,"filename"
        if_cc {
-            iteration_in_progress = true
-            have_first_byte = false
-            void c64.CHKIN(11)        ; use #11 as input channel
-            if_cc {
-                first_byte = c64.CHRIN()   ; read first byte to test for file not found
-                if not c64.READST() {
-                    have_first_byte = true
-                    return true
+            if c64.READST()==0 {
+                iteration_in_progress = true
+                have_first_byte = false
+                void c64.CHKIN(11)        ; use #11 as input channel
+                if_cc {
+                    first_byte = c64.CHRIN()   ; read first byte to test for file not found
+                    if not c64.READST() {
+                        have_first_byte = true
+                        return true
+                    }
                }
            }
        }
@@ -228,6 +228,8 @@ close_end:
    sub f_read(uword bufferpointer, uword num_bytes) -> uword {
        ; -- read from the currently open file, up to the given number of bytes.
        ;    returns the actual number of bytes read.  (checks for End-of-file and error conditions)
+        ;    NOTE: on systems with banked ram (such as Commander X16) this routine DOES NOT
+        ;          automatically load into subsequent banks if it reaches a bank boundary!
        if not iteration_in_progress or not num_bytes
            return 0

@@ -241,6 +243,7 @@ close_end:
        }

        void c64.CHKIN(11)        ; use #11 as input channel again
+
        %asm {{
            lda  bufferpointer
            sta  m_in_buffer+1
@@ -263,13 +266,15 @@ m_in_buffer     sta  $ffff

            if cx16.r5==$0d {   ; chance on I/o error status?
                first_byte = c64.READST()
-                if first_byte & $40
+                if first_byte & $40 {
                    f_close()       ; end of file, close it
+                    list_blocks--   ; don't count that last CHRIN read
+                }
                if first_byte
-                    return list_blocks
+                    return list_blocks  ; number of bytes read
            }
        }
-        return list_blocks
+        return list_blocks  ; number of bytes read
    }

    sub f_read_all(uword bufferpointer) -> uword {
@@ -277,19 +282,20 @@ m_in_buffer     sta  $ffff
        if not iteration_in_progress
            return 0

-        list_blocks = 0     ; we reuse this variable for the total number of bytes read
+        uword total_read = 0
        if have_first_byte {
            have_first_byte=false
            @(bufferpointer) = first_byte
            bufferpointer++
-            list_blocks++
+            total_read = 1
        }

        while not c64.READST() {
-            list_blocks += f_read(bufferpointer, 256)
-            bufferpointer += 256
+            uword size = f_read(bufferpointer, 256)
+            total_read += size
+            bufferpointer += size
        }
-        return list_blocks
+        return total_read
    }

    asmsub f_readline(uword bufptr @AY) clobbers(X) -> ubyte @Y {
@@ -339,7 +345,7 @@ _end        rts

    ; ----- iterative file saver functions (uses io channel 14) -----

-    sub f_open_w(ubyte drivenumber, uword filenameptr) -> ubyte {
+    sub f_open_w(ubyte drivenumber, uword filenameptr) -> bool {
        ; -- open a file for iterative writing with f_write
        f_close_w()

@@ -354,7 +360,7 @@ _end        rts
        return false
    }

-    sub f_write(uword bufferpointer, uword num_bytes) -> ubyte {
+    sub f_write(uword bufferpointer, uword num_bytes) -> bool {
        ; -- write the given umber of bytes to the currently open file
        if num_bytes!=0 {
            void c64.CHKOUT(14)        ; use #14 as input channel again
@@ -389,11 +395,14 @@ _end        rts
            goto io_error

        while not c64.READST() {
-            @(messageptr) = c64.CHRIN()
+            first_byte = c64.CHRIN()
+            if first_byte=='\r' or first_byte=='\n'
+                break
+            @(messageptr) = first_byte
            messageptr++
        }
-
        @(messageptr) = 0
+
 done:
        c64.CLRCHN()        ; restore default i/o devices
        c64.CLOSE(15)
@@ -404,7 +413,7 @@ io_error:
        goto done
    }

-    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> ubyte {
+    sub save(ubyte drivenumber, uword filenameptr, uword address, uword size) -> bool {
        c64.SETNAM(string.length(filenameptr), filenameptr)
        c64.SETLFS(1, drivenumber, 0)
        uword @shared end_address = address + size
@@ -474,7 +483,7 @@ io_error:

    ; Internal routine, only to be used on Commander X16 platform if headerless=true,
    ; because this routine uses kernal support for that to load headerless files.
-    sub load_headerless_cx16(ubyte drivenumber, uword filenameptr, uword address_override, ubyte headerless) -> uword {
+    sub load_headerless_cx16(ubyte drivenumber, uword filenameptr, uword address_override, bool headerless) -> uword {
        c64.SETNAM(string.length(filenameptr), filenameptr)
        ubyte secondary = 1
        cx16.r1 = 0
@@ -0,0 +1,235 @@
+floats {
+    ; the floating point functions shared across compiler targets
+    %option merge
+
+sub print_f(float value) {
+	; ---- prints the floating point value (without a newline).
+	%asm {{
+		stx  floats_store_reg
+		lda  #<value
+		ldy  #>value
+		jsr  MOVFM		; load float into fac1
+		jsr  FOUT		; fac1 to string in A/Y
+		sta  P8ZP_SCRATCH_W1
+		sty  P8ZP_SCRATCH_W1+1
+		ldy  #0
+-		lda  (P8ZP_SCRATCH_W1),y
+		beq  +
+		jsr  c64.CHROUT
+		iny
+		bne  -
+		ldx  floats_store_reg
+		rts
+	}}
+}
+
+sub pow(float value, float power) -> float {
+    %asm {{
+        stx  P8ZP_SCRATCH_W1
+        sty  P8ZP_SCRATCH_W1+1
+        lda  #<value
+        ldy  #>value
+        jsr  floats.CONUPK
+        lda  #<power
+        ldy  #>power
+        jsr  floats.FPWR
+        ldx  P8ZP_SCRATCH_W1
+        ldy  P8ZP_SCRATCH_W1+1
+        rts
+    }}
+}
+
+sub fabs(float value) -> float {
+    %asm {{
+        stx  P8ZP_SCRATCH_REG
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        jsr  ABS
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub sin(float angle) -> float {
+    %asm {{
+        lda  #<angle
+        ldy  #>angle
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  SIN
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub cos(float angle) -> float {
+    %asm {{
+        lda  #<angle
+        ldy  #>angle
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  COS
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub tan(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  TAN
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub atan(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  ATN
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub ln(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  LOG
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub log2(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  LOG
+        jsr  MOVEF
+        lda  #<FL_LOG2_const
+        ldy  #>FL_LOG2_const
+        jsr  MOVFM
+        jsr  FDIVT
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub sqrt(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  SQR
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub rad(float angle) -> float {
+    ; -- convert degrees to radians (d * pi / 180)
+    %asm {{
+        lda  #<angle
+        ldy  #>angle
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        lda  #<_pi_div_180
+        ldy  #>_pi_div_180
+        jsr  FMULT
+        ldx  P8ZP_SCRATCH_REG
+        rts
+_pi_div_180	.byte 123, 14, 250, 53, 18		; pi / 180
+    }}
+}
+
+sub deg(float angle) -> float {
+    ; -- convert radians to degrees (d * (1/ pi * 180))
+    %asm {{
+        lda  #<angle
+        ldy  #>angle
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        lda  #<_one_over_pi_div_180
+        ldy  #>_one_over_pi_div_180
+        jsr  FMULT
+        ldx  P8ZP_SCRATCH_REG
+        rts
+_one_over_pi_div_180	.byte 134, 101, 46, 224, 211		; 1 / (pi * 180)
+    }}
+}
+
+sub round(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  FADDH
+        jsr  INT
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub floor(float value) -> float {
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        jsr  INT
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub ceil(float value) -> float {
+    ; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
+    %asm {{
+        lda  #<value
+        ldy  #>value
+        jsr  MOVFM
+        stx  P8ZP_SCRATCH_REG
+        ldx  #<fmath_float1
+        ldy  #>fmath_float1
+        jsr  MOVMF
+        jsr  INT
+        lda  #<fmath_float1
+        ldy  #>fmath_float1
+        jsr  FCOMP
+        cmp  #0
+        beq  +
+        lda  #<FL_ONE_const
+        ldy  #>FL_ONE_const
+        jsr  FADD
+       ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+sub rndf() -> float {
+    %asm {{
+        stx  P8ZP_SCRATCH_REG
+        lda  #1
+        jsr  FREADSA
+        jsr  RND		; rng into fac1
+        ldx  P8ZP_SCRATCH_REG
+        rts
+    }}
+}
+
+}
@@ -1,8 +1,6 @@
 ; Internal Math library routines - always included by the compiler
 ; Generic machine independent 6502 code.
 ;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;
 ;  some more interesting routines can be found here:
 ;	http://6502org.wikidot.com/software-math
 ;	http://codebase64.org/doku.php?id=base:6502_6510_maths
@@ -1,7 +1,181 @@
 ; Internal Math library routines - always included by the compiler
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 math {
 	%asminclude "library:math.asm"
+
+    asmsub sin8u(ubyte angle @A) clobbers(Y) -> ubyte @A {
+        %asm {{
+		tay
+		lda  _sinecos8u,y
+		rts
+_sinecos8u	.byte  trunc(128.0 + 127.5 * sin(range(256+64) * rad(360.0/256.0)))
+        }}
+    }
+
+    asmsub cos8u(ubyte angle @A) clobbers(Y) -> ubyte @A {
+        %asm {{
+		tay
+		lda  sin8u._sinecos8u+64,y
+		rts
+        }}
+    }
+
+    asmsub sin8(ubyte angle @A) clobbers(Y) -> byte @A {
+        %asm {{
+		tay
+		lda  _sinecos8,y
+		rts
+_sinecos8	.char  trunc(127.0 * sin(range(256+64) * rad(360.0/256.0)))
+        }}
+    }
+
+    asmsub cos8(ubyte angle @A) clobbers(Y) -> byte @A {
+        %asm {{
+		tay
+		lda  sin8._sinecos8+64,y
+		rts
+        }}
+    }
+
+    asmsub sin16(ubyte angle @A) -> word @AY {
+        %asm {{
+		tay
+		lda  _sinecos8lo,y
+		pha
+		lda  _sinecos8hi,y
+		tay
+		pla
+		rts
+_  :=  trunc(32767.0 * sin(range(256+64) * rad(360.0/256.0)))
+_sinecos8lo     .byte  <_
+_sinecos8hi     .byte  >_
+        }}
+    }
+
+    asmsub cos16(ubyte angle @A) -> word @AY {
+        %asm {{
+		tay
+		lda  sin16._sinecos8lo+64,y
+		pha
+		lda  sin16._sinecos8hi+64,y
+		tay
+		pla
+		rts
+        }}
+    }
+
+    asmsub sin16u(ubyte angle @A) -> uword @AY {
+        %asm {{
+		tay
+		lda  _sinecos8ulo,y
+		pha
+		lda  _sinecos8uhi,y
+		tay
+		pla
+		rts
+_  :=  trunc(32768.0 + 32767.5 * sin(range(256+64) * rad(360.0/256.0)))
+_sinecos8ulo     .byte  <_
+_sinecos8uhi     .byte  >_
+        }}
+    }
+
+    asmsub cos16u(ubyte angle @A) -> uword @AY {
+        %asm {{
+		tay
+		lda  sin16u._sinecos8ulo+64,y
+		pha
+		lda  sin16u._sinecos8uhi+64,y
+		tay
+		pla
+		rts
+        }}
+    }
+
+    asmsub sinr8u(ubyte radians @A) clobbers(Y) -> ubyte @A {
+        %asm {{
+		tay
+		lda  _sinecosR8u,y
+		rts
+_sinecosR8u	.byte  trunc(128.0 + 127.5 * sin(range(180+45) * rad(360.0/180.0)))
+        }}
+    }
+
+    asmsub cosr8u(ubyte radians @A) clobbers(Y) -> ubyte @A {
+        %asm {{
+		tay
+		lda  sinr8u._sinecosR8u+45,y
+		rts
+        }}
+    }
+
+    asmsub sinr8(ubyte radians @A) clobbers(Y) -> byte @A {
+        %asm {{
+		tay
+		lda  _sinecosR8,y
+		rts
+_sinecosR8	.char  trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
+        }}
+    }
+
+    asmsub cosr8(ubyte radians @A) clobbers(Y) -> byte @A {
+        %asm {{
+		tay
+		lda  sinr8._sinecosR8+45,y
+		rts
+        }}
+    }
+
+    asmsub sinr16(ubyte radians @A) -> word @AY {
+        %asm {{
+		tay
+		lda  _sinecosR8lo,y
+		pha
+		lda  _sinecosR8hi,y
+		tay
+		pla
+		rts
+_  :=  trunc(32767.0 * sin(range(180+45) * rad(360.0/180.0)))
+_sinecosR8lo     .byte  <_
+_sinecosR8hi     .byte  >_
+        }}
+    }
+
+    asmsub cosr16(ubyte radians @A) -> word @AY {
+        %asm {{
+		tay
+		lda  sinr16._sinecosR8lo+45,y
+		pha
+		lda  sinr16._sinecosR8hi+45,y
+		tay
+		pla
+		rts
+        }}
+    }
+
+    asmsub sinr16u(ubyte radians @A) -> uword @AY {
+        %asm {{
+		tay
+		lda  _sinecosR8ulo,y
+		pha
+		lda  _sinecosR8uhi,y
+		tay
+		pla
+		rts
+_  :=  trunc(32768.0 + 32767.5 * sin(range(180+45) * rad(360.0/180.0)))
+_sinecosR8ulo     .byte  <_
+_sinecosR8uhi     .byte  >_
+        }}
+    }
+
+    asmsub cosr16u(ubyte radians @A) -> uword @AY {
+        %asm {{
+		tay
+		lda  sinr16u._sinecosR8ulo+45,y
+		pha
+		lda  sinr16u._sinecosR8uhi+45,y
+		tay
+		pla
+		rts
+        }}
+    }
 }
@@ -84,304 +84,18 @@ func_all_w_stack	.proc
 		rts
 		.pend

-func_sin8_into_A	.proc
-		tay
-		lda  _sinecos8,y
-		rts
-_sinecos8	.char  trunc(127.0 * sin(range(256+64) * rad(360.0/256.0)))
-		.pend
-
-func_sinr8_into_A	.proc
-		tay
-		lda  _sinecosR8,y
-		rts
-_sinecosR8	.char  trunc(127.0 * sin(range(180+45) * rad(360.0/180.0)))
-		.pend
-
-func_sin8u_into_A	.proc
-		tay
-		lda  _sinecos8u,y
-		rts
-_sinecos8u	.byte  trunc(128.0 + 127.5 * sin(range(256+64) * rad(360.0/256.0)))
-		.pend
-
-func_sinr8u_into_A	.proc
-		tay
-		lda  _sinecosR8u,y
-		rts
-_sinecosR8u	.byte  trunc(128.0 + 127.5 * sin(range(180+45) * rad(360.0/180.0)))
-		.pend
-
-func_sin8_stack	.proc
-		tay
-		lda  func_sin8_into_A._sinecos8,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sinr8_stack	.proc
-		tay
-		lda  func_sinr8_into_A._sinecosR8,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sin8u_stack	.proc
-		tay
-		lda  func_sin8u_into_A._sinecos8u,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sinr8u_stack	.proc
-		tay
-		lda  func_sinr8u_into_A._sinecosR8u,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_cos8_into_A	.proc
-		tay
-		lda  func_sin8_into_A._sinecos8+64,y
-		rts
-		.pend
-
-func_cosr8_into_A	.proc
-		tay
-		lda  func_sinr8_into_A._sinecosR8+45,y
-		rts
-		.pend
-
-func_cos8u_into_A	.proc
-		tay
-		lda  func_sin8u_into_A._sinecos8u+64,y
-		rts
-		.pend
-
-func_cosr8u_into_A	.proc
-		tay
-		lda  func_sinr8u_into_A._sinecosR8u+45,y
-		rts
-		.pend
-
-func_cos8_stack	.proc
-		tay
-		lda  func_sin8_into_A._sinecos8+64,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_cosr8_stack	.proc
-		tay
-		lda  func_sinr8_into_A._sinecosR8+45,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_cos8u_stack	.proc
-		tay
-		lda  func_sin8u_into_A._sinecos8u+64,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_cosr8u_stack	.proc
-		tay
-		lda  func_sinr8u_into_A._sinecosR8u+45,y
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_sin16_into_AY	.proc
-		tay
-		lda  _sinecos8lo,y
-		pha
-		lda  _sinecos8hi,y
-		tay
-		pla
-		rts
-_  :=  trunc(32767.0 * sin(range(256+64) * rad(360.0/256.0)))
-_sinecos8lo     .byte  <_
-_sinecos8hi     .byte  >_
-		.pend
-
-func_sinr16_into_AY	.proc
-		tay
-		lda  _sinecosR8lo,y
-		pha
-		lda  _sinecosR8hi,y
-		tay
-		pla
-		rts
-_  :=  trunc(32767.0 * sin(range(180+45) * rad(360.0/180.0)))
-_sinecosR8lo     .byte  <_
-_sinecosR8hi     .byte  >_
-		.pend
-
-func_sin16u_into_AY	.proc
-		tay
-		lda  _sinecos8ulo,y
-		pha
-		lda  _sinecos8uhi,y
-		tay
-		pla
-		rts
-_  :=  trunc(32768.0 + 32767.5 * sin(range(256+64) * rad(360.0/256.0)))
-_sinecos8ulo     .byte  <_
-_sinecos8uhi     .byte  >_
-		.pend
-
-func_sinr16u_into_AY	.proc
-		tay
-		lda  _sinecosR8ulo,y
-		pha
-		lda  _sinecosR8uhi,y
-		tay
-		pla
-		rts
-_  :=  trunc(32768.0 + 32767.5 * sin(range(180+45) * rad(360.0/180.0)))
-_sinecosR8ulo     .byte  <_
-_sinecosR8uhi     .byte  >_
-		.pend
-
-func_sin16_stack	.proc
-		tay
-		lda  func_sin16_into_AY._sinecos8lo,y
-		sta  P8ESTACK_LO,x
-		lda  func_sin16_into_AY._sinecos8hi,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_sinr16_stack	.proc
-		tay
-		lda  func_sinr16_into_AY._sinecosR8lo,y
-		sta  P8ESTACK_LO,x
-		lda  func_sinr16_into_AY._sinecosR8hi,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_sin16u_stack	.proc
-		tay
-		lda  func_sin16u_into_AY._sinecos8ulo,y
-		sta  P8ESTACK_LO,x
-		lda  func_sin16u_into_AY._sinecos8uhi,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_sinr16u_stack	.proc
-		tay
-		lda  func_sinr16u_into_AY._sinecosR8ulo,y
-		sta  P8ESTACK_LO,x
-		lda  func_sinr16u_into_AY._sinecosR8uhi,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_cos16_into_AY	.proc
-		tay
-		lda  func_sin16_into_AY._sinecos8lo+64,y
-		pha
-		lda  func_sin16_into_AY._sinecos8hi+64,y
-		tay
-		pla
-		rts
-		.pend
-
-func_cosr16_into_AY	.proc
-		tay
-		lda  func_sinr16_into_AY._sinecosR8lo+45,y
-		pha
-		lda  func_sinr16_into_AY._sinecosR8hi+45,y
-		tay
-		pla
-		rts
-		.pend
-
-func_cos16u_into_AY	.proc
-		tay
-		lda  func_sin16u_into_AY._sinecos8ulo+64,y
-		pha
-		lda  func_sin16u_into_AY._sinecos8uhi+64,y
-		tay
-		pla
-		rts
-		.pend
-
-func_cosr16u_into_AY	.proc
-		tay
-		lda  func_sinr16u_into_AY._sinecosR8ulo+45,y
-		pha
-		lda  func_sinr16u_into_AY._sinecosR8uhi+45,y
-		tay
-		pla
-		rts
-		.pend
-
-func_cos16_stack	.proc
-		tay
-		lda  func_sin16_into_AY._sinecos8lo+64,y
-		sta  P8ESTACK_LO,x
-		lda  func_sin16_into_AY._sinecos8hi+64,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_cosr16_stack	.proc
-		tay
-		lda  func_sinr16_into_AY._sinecosR8lo+45,y
-		sta  P8ESTACK_LO,x
-		lda  func_sinr16_into_AY._sinecosR8hi+45,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_cos16u_stack	.proc
-		tay
-		lda  func_sin16u_into_AY._sinecos8ulo+64,y
-		sta  P8ESTACK_LO,x
-		lda  func_sin16u_into_AY._sinecos8uhi+64,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_cosr16u_stack	.proc
-		tay
-		lda  func_sinr16u_into_AY._sinecosR8ulo+45,y
-		sta  P8ESTACK_LO,x
-		lda  func_sinr16u_into_AY._sinecosR8uhi+45,y
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
 abs_b_stack	.proc
-	; -- push abs(A) on stack (as byte)
-		jsr  abs_b_into_A
+	; -- push abs(A) on stack (as unsigned word)
+		jsr  abs_b_into_AY
 		sta  P8ESTACK_LO,x
+		stz  P8ESTACK_HI,x
 		dex
 		rts
 		.pend

-abs_b_into_A	.proc
-	; -- A = abs(A)
+abs_b_into_AY	.proc
+	; -- AY = abs(A)  (abs always returns unsigned word)
+		ldy  #0
 		cmp  #0
 		bmi  +
 		rts
@@ -548,394 +262,6 @@ func_rndw_stack	.proc
 		rts
 		.pend

-func_min_ub_into_A	.proc
-		; -- min(ubarray) -> A.  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		dey
-		lda  #255
-		sta  P8ZP_SCRATCH_B1
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  P8ZP_SCRATCH_B1
-		bcs  +
-		sta  P8ZP_SCRATCH_B1
-+		dey
-		cpy  #255
-		bne  -
-		lda  P8ZP_SCRATCH_B1
-		rts
-				.pend
-
-func_min_ub_stack	.proc
-		jsr  func_min_ub_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_min_b_into_A	.proc
-		; -- min(barray) -> A.  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		dey
-		lda  #127
-		sta  P8ZP_SCRATCH_B1
-		lda  (P8ZP_SCRATCH_W1),y
-		clc
-		sbc  P8ZP_SCRATCH_B1
-		bvc  +
-		eor  #$80
-+		bpl  +
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ZP_SCRATCH_B1
-+		dey
-		cpy  #255
-		bne  -
-		lda  P8ZP_SCRATCH_B1
-		rts
-		.pend
-
-func_min_b_stack	.proc
-		jsr  func_min_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_min_uw_into_AY	.proc
-		; -- min(uwarray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		asl  a
-		tay
-		dey
-		dey
-		lda  #$ff
-		sta  _result_minuw
-		sta  _result_minuw+1
-_loop
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		dey
-		cmp   _result_minuw+1
-		bcc  _less
-		bne  _gtequ
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  _result_minuw
-		bcs  _gtequ
-_less		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_minuw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_minuw+1
-		dey
-_gtequ		dey
-		dey
-		cpy  #254
-		bne  _loop
-		lda  _result_minuw
-		ldy  _result_minuw+1
-		rts
-_result_minuw	.word  0
-		.pend
-
-func_min_w_into_AY	.proc
-		; -- min(warray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		asl  a
-		tay
-		dey
-		dey
-		lda  #$ff
-		sta  _result_minw
-		lda  #$7f
-		sta  _result_minw+1
-_loop
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp   _result_minw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		dey
-		sbc  _result_minw+1
-		bvc  +
-		eor  #$80
-+		bpl  _gtequ
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_minw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_minw+1
-		dey
-_gtequ		dey
-		dey
-		cpy  #254
-		bne  _loop
-		lda  _result_minw
-		ldy  _result_minw+1
-		rts
-_result_minw	.word  0
-		.pend
-
-func_min_uw_stack	.proc
-		jsr  func_min_uw_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_min_w_stack	.proc
-		jsr  func_min_w_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_max_ub_into_A	.proc
-		; -- max(ubarray) -> A  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		dey
-		lda  #0
-		sta  P8ZP_SCRATCH_B1
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  P8ZP_SCRATCH_B1
-		bcc  +
-		sta  P8ZP_SCRATCH_B1
-+		dey
-		cpy  #255
-		bne  -
-		lda  P8ZP_SCRATCH_B1
-		rts
-		.pend
-
-func_max_ub_stack	.proc
-		jsr  func_max_ub_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_max_b_into_A	.proc
-		; -- max(barray) -> A  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		lda  #-128
-		sta  P8ZP_SCRATCH_B1
-		lda  (P8ZP_SCRATCH_W1),y
-		sec
-		sbc  P8ZP_SCRATCH_B1
-		bvc  +
-		eor  #$80
-+		bmi  +
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  P8ZP_SCRATCH_B1
-+		dey
-		cpy  #255
-		bne  -
-		lda  P8ZP_SCRATCH_B1
-		rts
-		.pend
-
-func_max_b_stack	.proc
-		jsr  func_max_b_into_A
-		sta  P8ESTACK_LO,x
-		dex
-		rts
-		.pend
-
-func_max_uw_into_AY	.proc
-		; -- max(uwarray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		asl  a
-		tay
-		dey
-		dey
-		lda  #0
-		sta  _result_maxuw
-		sta  _result_maxuw+1
-_loop
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		dey
-		cmp  _result_maxuw+1
-		bcc  _lesseq
-		bne  _greater
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  _result_maxuw
-		bcc  _lesseq
-_greater	lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_maxuw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_maxuw+1
-		dey
-_lesseq		dey
-		dey
-		cpy  #254
-		bne  _loop
-		lda  _result_maxuw
-		ldy  _result_maxuw+1
-		rts
-_result_maxuw	.word  0
-		.pend
-
-func_max_uw_stack	.proc
-		jsr  func_max_uw_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_max_w_into_AY	.proc
-		; -- max(uwarray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		asl  a
-		tay
-		dey
-		dey
-		lda  #0
-		sta  _result_maxw
-		lda  #$80
-		sta  _result_maxw+1
-_loop
-		lda  (P8ZP_SCRATCH_W1),y
-		cmp  _result_maxw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		dey
-		sbc  _result_maxw+1
-		bvc  +
-		eor  #$80
-+		bmi  _lesseq
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_maxw
-		iny
-		lda  (P8ZP_SCRATCH_W1),y
-		sta  _result_maxw+1
-		dey
-_lesseq		dey
-		dey
-		cpy  #254
-		bne  _loop
-		lda  _result_maxw
-		ldy  _result_maxw+1
-		rts
-_result_maxw	.word  0
-		.pend
-
-func_max_w_stack	.proc
-		jsr  func_max_w_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_sum_ub_into_AY	.proc
-		; -- sum(ubarray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		dey
-		lda  #0
-		sta  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2+1
-		lda  (P8ZP_SCRATCH_W1),y
-		clc
-		adc  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2
-		bcc  +
-		inc  P8ZP_SCRATCH_W2+1
-+		dey
-		cpy  #255
-		bne  -
-		lda  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		rts
-		.pend
-
-func_sum_ub_stack	.proc
-		jsr  func_sum_ub_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-
-func_sum_b_into_AY	.proc
-		; -- sum(barray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		tay
-		dey
-		lda  #0
-		sta  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2+1
-_loop		lda  (P8ZP_SCRATCH_W1),y
-		pha
-		clc
-		adc  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2
-		; sign extend the high byte
-		pla
-		and  #$80
-		beq  +
-		lda  #$ff
-+		adc  P8ZP_SCRATCH_W2+1
-		sta  P8ZP_SCRATCH_W2+1
-		dey
-		cpy  #255
-		bne  _loop
-		lda  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		rts
-		.pend
-
-func_sum_b_stack	.proc
-		jsr  func_sum_b_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-func_sum_uw_into_AY	.proc
-		; -- sum(uwarray) -> AY  (array in P8ZP_SCRATCH_W1, num elements in A)
-		asl  a
-		tay
-		dey
-		dey
-		lda  #0
-		sta  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2+1
-		lda  (P8ZP_SCRATCH_W1),y
-		iny
-		clc
-		adc  P8ZP_SCRATCH_W2
-		sta  P8ZP_SCRATCH_W2
-		lda  (P8ZP_SCRATCH_W1),y
-		adc  P8ZP_SCRATCH_W2+1
-		sta  P8ZP_SCRATCH_W2+1
-		dey
-		dey
-		dey
-		cpy  #254
-		bne  -
-		lda  P8ZP_SCRATCH_W2
-		ldy  P8ZP_SCRATCH_W2+1
-		rts
-		.pend
-
-func_sum_uw_stack	.proc
-		jsr  func_sum_uw_into_AY
-		sta  P8ESTACK_LO,x
-		tya
-		sta  P8ESTACK_HI,x
-		dex
-		rts
-		.pend
-
-
-func_sum_w_into_AY = func_sum_uw_into_AY
-func_sum_w_stack = func_sum_uw_stack
-

 func_sort_ub	.proc
 		; 8bit unsigned sort
@@ -1,7 +1,5 @@
 ; Internal library routines - always included by the compiler
 ; Generic machine independent 6502 code.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0


 orig_stackpointer	.byte  0	; stores the Stack pointer register at program start
@@ -60,27 +58,6 @@ inv_word	.proc
 		rts
 		.pend

-not_byte	.proc
-		lda  P8ESTACK_LO+1,x
-		beq  +
-		lda  #1
-+		eor  #1
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-not_word	.proc
-		lda  P8ESTACK_LO + 1,x
-		ora  P8ESTACK_HI + 1,x
-		beq  +
-		lda  #1
-+		eor  #1
-		sta  P8ESTACK_LO + 1,x
-		lsr  a
-		sta  P8ESTACK_HI + 1,x
-		rts
-		.pend
-
 bitand_b	.proc
 		; -- bitwise and (of 2 bytes)
 		lda  P8ESTACK_LO+2,x
@@ -144,98 +121,6 @@ bitxor_w	.proc
 		rts
 		.pend

-and_b		.proc
-		; -- logical and (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		beq  +
-		lda  #1
-+		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		beq  +
-		lda  #1
-+		and  P8ZP_SCRATCH_B1
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-or_b		.proc
-		; -- logical or (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		beq  +
-		lda  #1
-+		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-xor_b		.proc
-		; -- logical xor (of 2 bytes)
-		lda  P8ESTACK_LO+2,x
-		beq  +
-		lda  #1
-+		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		beq  +
-		lda  #1
-+		eor  P8ZP_SCRATCH_B1
-		inx
-		sta  P8ESTACK_LO+1,x
-		rts
-		.pend
-
-and_w		.proc
-		; -- logical and (word and word -> byte)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_HI+2,x
-		beq  +
-		lda  #1
-+		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  +
-		lda  #1
-+		and  P8ZP_SCRATCH_B1
-		inx
- 		sta  P8ESTACK_LO+1,x
- 		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-or_w		.proc
-		; -- logical or (word or word -> byte)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+2,x
-		ora  P8ESTACK_HI+1,x
-		beq  +
-		lda  #1
-+		inx
-		sta  P8ESTACK_LO+1,x
-		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-xor_w		.proc
-		; -- logical xor (word xor word -> byte)
-		lda  P8ESTACK_LO+2,x
-		ora  P8ESTACK_HI+2,x
-		beq  +
-		lda  #1
-+		sta  P8ZP_SCRATCH_B1
-		lda  P8ESTACK_LO+1,x
-		ora  P8ESTACK_HI+1,x
-		beq  +
-		lda  #1
-+		eor  P8ZP_SCRATCH_B1
-		inx
- 		sta  P8ESTACK_LO+1,x
- 		sta  P8ESTACK_HI+1,x
-		rts
-		.pend
-
-

 add_w		.proc
 	; -- push word+word / uword+uword
@@ -780,13 +665,10 @@ greaterequalzero_sb	.proc

 greaterequalzero_sw	.proc
 		lda  P8ESTACK_HI+1,x
-		bmi  equalzero_b._false
-		ora  P8ESTACK_LO+1,x
-		beq  equalzero_b._true
-		bne  equalzero_b._false
+	    	bpl  equalzero_b._true
+	    	bmi  equalzero_b._false
 		.pend

-
 memcopy16_up	.proc
 	; -- copy memory UP from (P8ZP_SCRATCH_W1) to (P8ZP_SCRATCH_W2) of length X/Y (16-bit, X=lo, Y=hi)
 	;    clobbers register A,X,Y
@@ -1,6 +1,4 @@
 ; Internal library routines - always included by the compiler
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 prog8_lib {
 	%asminclude "library:prog8_lib.asm"
@@ -1,7 +1,4 @@
 ; 0-terminated string manipulation routines.
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-

 string {

@@ -0,0 +1,263 @@
+; Number conversions routines.
+
+conv {
+
+; ----- number conversions to decimal strings ----
+
+    str  string_out = "????????????????"       ; result buffer for the string conversion routines
+
+sub  str_ub0(ubyte value)   {
+    ; ---- convert the ubyte in A in decimal string form, with left padding 0s (3 positions total)
+    ubyte hundreds = value / 100
+    value -= hundreds*100
+    ubyte tens = value / 10
+    value -= tens*10
+    string_out[0] = hundreds+'0'
+    string_out[1] = tens+'0'
+    string_out[2] = value+'0'
+    string_out[3] = 0
+}
+
+sub  str_ub(ubyte value) {
+    ; ---- convert the ubyte in A in decimal string form, without left padding 0s
+    internal_str_ub(value, string_out)
+}
+
+sub  str_b(byte value) {
+    ; ---- convert the byte in A in decimal string form, without left padding 0s
+    uword out_ptr = &string_out
+    if value<0 {
+        @(out_ptr) = '-'
+        out_ptr++
+        value = -value
+    }
+    internal_str_ub(value as ubyte, out_ptr)
+}
+
+sub internal_str_ub(ubyte value, uword out_ptr) {
+    ubyte hundreds = value / 100
+    value -= hundreds*100
+    ubyte tens = value / 10
+    value -= tens*10
+    if hundreds
+        goto output_hundreds
+    if tens
+        goto output_tens
+    goto output_ones
+output_hundreds:
+    @(out_ptr) = hundreds+'0'
+    out_ptr++
+output_tens:
+    @(out_ptr) = tens+'0'
+    out_ptr++
+output_ones:
+    @(out_ptr) = value+'0'
+    out_ptr++
+    @(out_ptr) = 0
+}
+
+str hex_digits = "0123456789abcdef"
+
+sub  str_ubhex  (ubyte value)  {
+    ; ---- convert the ubyte in A in hex string form
+    string_out[0] = hex_digits[value>>4]
+    string_out[1] = hex_digits[value&15]
+    string_out[2] = 0
+}
+
+sub  str_ubbin  (ubyte value)  {
+    ; ---- convert the ubyte in A in binary string form
+    uword out_ptr = &string_out
+    repeat 8 {
+        rol(value)
+        if_cc
+            @(out_ptr) = '0'
+        else
+            @(out_ptr) = '1'
+        out_ptr++
+    }
+    @(out_ptr) = 0
+}
+
+sub  str_uwbin  (uword value) {
+    ; ---- convert the uword in A/Y in binary string form
+    uword out_ptr = &string_out
+    repeat 16 {
+        rol(value)
+        if_cc
+            @(out_ptr) = '0'
+        else
+            @(out_ptr) = '1'
+        out_ptr++
+    }
+    @(out_ptr) = 0
+}
+
+sub  str_uwhex  (uword value) {
+    ; ---- convert the uword in A/Y in hexadecimal string form (4 digits)
+    ubyte bits = msb(value)
+    string_out[0] = hex_digits[bits>>4]
+    string_out[1] = hex_digits[bits&15]
+    bits = lsb(value)
+    string_out[2] = hex_digits[bits>>4]
+    string_out[3] = hex_digits[bits&15]
+    string_out[4] = 0
+}
+
+sub  str_uw0  (uword value) {
+    ; ---- convert the uword in A/Y in decimal string form, with left padding 0s (5 positions total)
+    ubyte tenthousands = (value / 10000) as ubyte
+    value -= 10000*tenthousands
+    ubyte thousands = (value / 1000) as ubyte
+    value -= 1000*thousands
+    ubyte hundreds = (value / 100) as ubyte
+    value -= 100 as uword * hundreds
+    ubyte tens = (value / 10) as ubyte
+    value -= 10*tens
+    string_out[0] = tenthousands+'0'
+    string_out[1] = thousands+'0'
+    string_out[2] = hundreds+'0'
+    string_out[3] = tens+'0'
+    string_out[4] = value as ubyte + '0'
+    string_out[5] = 0
+}
+
+sub  str_uw  (uword value)  {
+    ; ---- convert the uword in A/Y in decimal string form, without left padding 0s
+    internal_str_uw(value, string_out)
+}
+
+sub  str_w  (word value)  {
+    ; ---- convert the (signed) word in A/Y in decimal string form, without left padding 0's
+    uword out_ptr = &string_out
+    if value<0 {
+        @(out_ptr) = '-'
+        out_ptr++
+        value = -value
+    }
+    internal_str_uw(value as uword, out_ptr)
+}
+
+sub internal_str_uw(uword value, uword out_ptr) {
+    ubyte tenthousands = (value / 10000) as ubyte
+    value -= 10000*tenthousands
+    ubyte thousands = (value / 1000) as ubyte
+    value -= 1000*thousands
+    ubyte hundreds = (value / 100) as ubyte
+    value -= 100 as uword * hundreds
+    ubyte tens = (value / 10) as ubyte
+    value -= 10*tens
+    if tenthousands
+        goto output_tenthousands
+    if thousands
+        goto output_thousands
+    if hundreds
+        goto output_hundreds
+    if tens
+        goto output_tens
+    goto output_ones
+output_tenthousands:
+    @(out_ptr) = tenthousands+'0'
+    out_ptr++
+output_thousands:
+    @(out_ptr) = thousands+'0'
+    out_ptr++
+output_hundreds:
+    @(out_ptr) = hundreds+'0'
+    out_ptr++
+output_tens:
+    @(out_ptr) = tens+'0'
+    out_ptr++
+output_ones:
+    @(out_ptr) = value as ubyte + '0'
+    out_ptr++
+    @(out_ptr) = 0
+}
+
+
+; ---- string conversion to numbers -----
+
+sub  str2ubyte(str string) -> ubyte {
+    ; -- returns in A the unsigned byte value of the string number argument in AY
+    ;    the number may NOT be preceded by a + sign and may NOT contain spaces
+    ;    (any non-digit character will terminate the number string that is parsed)
+    return str2uword(string) as ubyte
+}
+
+sub  str2byte(str string) -> byte {
+    ; -- returns in A the signed byte value of the string number argument in AY
+    ;    the number may be preceded by a + or - sign but may NOT contain spaces
+    ;    (any non-digit character will terminate the number string that is parsed)
+    return str2word(string) as byte
+}
+
+sub  str2uword(str string) -> uword {
+    ; -- returns the unsigned word value of the string number argument in AY
+    ;    the number may NOT be preceded by a + sign and may NOT contain spaces
+    ;    (any non-digit character will terminate the number string that is parsed)
+    %asm {{
+        loadm.w r0, {conv.str2uword.string}
+        syscall 11
+        return
+    }}
+}
+
+sub  str2word(str string) -> word {
+    ; -- returns the signed word value of the string number argument in AY
+    ;    the number may be preceded by a + or - sign but may NOT contain spaces
+    ;    (any non-digit character will terminate the number string that is parsed)
+    %asm {{
+        loadm.w r0, {conv.str2word.string}
+        syscall 12
+        return
+    }}
+}
+
+sub  hex2uword(str string) -> uword {
+    ; -- hexadecimal string (with or without '$') to uword.
+    ;    stops parsing at the first character that's not a hex digit (except leading $)
+    uword result
+    ubyte char
+    if @(string)=='$'
+        string++
+    repeat {
+        char = @(string)
+        if char==0
+            return result
+        result <<= 4
+        if char>='0' and char<='9'
+            result |= char-'0'
+        else
+            result |= char-'a'+10
+        string++
+    }
+}
+
+sub  bin2uword(str string) -> uword {
+    ; -- binary string (with or without '%') to uword.
+    ;    stops parsing at the first character that's not a 0 or 1. (except leading %)
+    uword result
+    ubyte char
+    if @(string)=='%'
+        string++
+    repeat {
+        char = @(string)
+        if char==0
+            return result
+        result <<= 1
+        if char=='1'
+            result |= 1
+        string++
+    }
+}
+
+sub  any2uword(str string) -> uword {
+    ; -- convert any number string (any prefix allowed) to uword.
+    when string[0] {
+        '$' -> return hex2uword(string)
+        '%' -> return bin2uword(string)
+        else -> return str2uword(string)
+    }
+}
+
+}
@@ -0,0 +1,133 @@
+; Prog8 definitions for floating point handling on the VirtualMachine
+
+%option enable_floats
+
+floats {
+
+    const float  PI     = 3.141592653589793
+    const float  TWOPI  = 6.283185307179586
+
+sub print_f(float value) {
+    ; ---- prints the floating point value (without a newline).
+    %asm {{
+        loadm.f fr0,{floats.print_f.value}
+        syscall 25
+        return
+    }}
+}
+
+sub pow(float value, float power) -> float {
+    %asm {{
+        loadm.f fr0,{floats.pow.value}
+        loadm.f fr1,{floats.pow.power}
+        fpow.f fr0,fr1
+        return
+    }}
+}
+
+sub fabs(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.fabs.value}
+        fabs.f fr0,fr0
+        return
+    }}
+}
+
+sub sin(float angle) -> float {
+    %asm {{
+        loadm.f fr0,{floats.sin.angle}
+        fsin.f fr0,fr0
+        return
+    }}
+}
+
+sub cos(float angle) -> float {
+    %asm {{
+        loadm.f fr0,{floats.cos.angle}
+        fcos.f fr0,fr0
+        return
+    }}
+}
+
+sub tan(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.tan.value}
+        ftan.f fr0,fr0
+        return
+    }}
+}
+
+sub atan(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.atan.value}
+        fatan.f fr0,fr0
+        return
+    }}
+}
+
+sub ln(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.ln.value}
+        fln.f fr0,fr0
+        return
+    }}
+}
+
+sub log2(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.log2.value}
+        flog.f fr0,fr0
+        return
+    }}
+}
+
+sub sqrt(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.sqrt.value}
+        fsqrt.f fr0,fr0
+        return
+    }}
+}
+
+sub rad(float angle) -> float {
+    ; -- convert degrees to radians (d * pi / 180)
+    return angle * PI / 180.0
+}
+
+sub deg(float angle) -> float {
+    ; -- convert radians to degrees (d * (1/ pi * 180))
+    return angle * 180.0 / PI
+}
+
+sub round(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.round.value}
+        fround.f fr0,fr0
+        return
+    }}
+}
+
+sub floor(float value) -> float {
+    %asm {{
+        loadm.f fr0,{floats.floor.value}
+        ffloor.f fr0,fr0
+        return
+    }}
+}
+
+sub ceil(float value) -> float {
+    ; -- ceil: tr = int(f); if tr==f -> return  else return tr+1
+    %asm {{
+        loadm.f fr0,{floats.ceil.value}
+        fceil.f fr0,fr0
+        return
+    }}
+}
+
+sub rndf() -> float {
+    %asm {{
+        rnd.f fr0
+        return
+    }}
+}
+}
@@ -1,7 +1,127 @@
 ; Internal Math library routines - always included by the compiler
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 math {
-	; TODO
+
+    sub sin8u(ubyte angle) -> ubyte {
+        ubyte[256] sintab = [$80, $83, $86, $89, $8c, $8f, $92, $95, $98, $9b, $9e, $a2, $a5, $a7, $aa, $ad, $b0, $b3, $b6, $b9,
+                             $bc, $be, $c1, $c4, $c6, $c9, $cb, $ce, $d0, $d3, $d5, $d7, $da, $dc, $de, $e0,
+                             $e2, $e4, $e6, $e8, $ea, $eb, $ed, $ee, $f0, $f1, $f3, $f4, $f5, $f6, $f8, $f9,
+                             $fa, $fa, $fb, $fc, $fd, $fd, $fe, $fe, $fe, $ff, $ff, $ff, $ff, $ff, $ff, $ff,
+                             $fe, $fe, $fe, $fd, $fd, $fc, $fb, $fa, $fa, $f9, $f8, $f6, $f5, $f4, $f3, $f1,
+                             $f0, $ee, $ed, $eb, $ea, $e8, $e6, $e4, $e2, $e0, $de, $dc, $da, $d7, $d5, $d3,
+                             $d0, $ce, $cb, $c9, $c6, $c4, $c1, $be, $bc, $b9, $b6, $b3, $b0, $ad, $aa, $a7,
+                             $a5, $a2, $9e, $9b, $98, $95, $92, $8f, $8c, $89, $86, $83, $80, $7c, $79, $76,
+                             $73, $70, $6d, $6a, $67, $64, $61, $5d, $5a, $58, $55, $52, $4f, $4c, $49, $46,
+                             $43, $41, $3e, $3b, $39, $36, $34, $31, $2f, $2c, $2a, $28, $25, $23, $21, $1f,
+                             $1d, $1b, $19, $17, $15, $14, $12, $11, $0f, $0e, $0c, $0b, $0a, $09, $07, $06,
+                             $05, $05, $04, $03, $02, $02, $01, $01, $01, $00, $00, $00, $00, $00, $00, $00,
+                             $01, $01, $01, $02, $02, $03, $04, $05, $05, $06, $07, $09, $0a, $0b, $0c, $0e,
+                             $0f, $11, $12, $14, $15, $17, $19, $1b, $1d, $1f, $21, $23, $25, $28, $2a, $2c,
+                             $2f, $31, $34, $36, $39, $3b, $3e, $41, $43, $46, $49, $4c, $4f, $52, $55, $58,
+                             $5a, $5d, $61, $64, $67, $6a, $6d, $70, $73, $76, $79, $7c]
+       return sintab[angle]
+    }
+
+    sub cos8u(ubyte angle) -> ubyte {
+        ubyte[256] costab = [$ff, $ff, $ff, $ff,
+                             $fe, $fe, $fe, $fd, $fd, $fc, $fb, $fa, $fa, $f9, $f8, $f6, $f5, $f4, $f3, $f1,
+                             $f0, $ee, $ed, $eb, $ea, $e8, $e6, $e4, $e2, $e0, $de, $dc, $da, $d7, $d5, $d3,
+                             $d0, $ce, $cb, $c9, $c6, $c4, $c1, $be, $bc, $b9, $b6, $b3, $b0, $ad, $aa, $a7,
+                             $a5, $a2, $9e, $9b, $98, $95, $92, $8f, $8c, $89, $86, $83, $80, $7c, $79, $76,
+                             $73, $70, $6d, $6a, $67, $64, $61, $5d, $5a, $58, $55, $52, $4f, $4c, $49, $46,
+                             $43, $41, $3e, $3b, $39, $36, $34, $31, $2f, $2c, $2a, $28, $25, $23, $21, $1f,
+                             $1d, $1b, $19, $17, $15, $14, $12, $11, $0f, $0e, $0c, $0b, $0a, $09, $07, $06,
+                             $05, $05, $04, $03, $02, $02, $01, $01, $01, $00, $00, $00, $00, $00, $00, $00,
+                             $01, $01, $01, $02, $02, $03, $04, $05, $05, $06, $07, $09, $0a, $0b, $0c, $0e,
+                             $0f, $11, $12, $14, $15, $17, $19, $1b, $1d, $1f, $21, $23, $25, $28, $2a, $2c,
+                             $2f, $31, $34, $36, $39, $3b, $3e, $41, $43, $46, $49, $4c, $4f, $52, $55, $58,
+                             $5a, $5d, $61, $64, $67, $6a, $6d, $70, $73, $76, $79, $7c, $7f, $83, $86, $89,
+                             $8c, $8f, $92, $95, $98, $9b, $9e, $a2, $a5, $a7, $aa, $ad, $b0, $b3, $b6, $b9,
+                             $bc, $be, $c1, $c4, $c6, $c9, $cb, $ce, $d0, $d3, $d5, $d7, $da, $dc, $de, $e0,
+                             $e2, $e4, $e6, $e8, $ea, $eb, $ed, $ee, $f0, $f1, $f3, $f4, $f5, $f6, $f8, $f9,
+                             $fa, $fa, $fb, $fc, $fd, $fd, $fe, $fe, $fe, $ff, $ff, $ff ]
+       return costab[angle]
+    }
+
+    sub sin8(ubyte angle) -> byte {
+        return 42     ; TODO
+    }
+
+    sub cos8(ubyte angle) -> byte {
+        return 42     ; TODO
+    }
+
+    sub sin16(ubyte angle) -> word {
+        return 4242     ; TODO
+    }
+
+    sub cos16(ubyte angle) -> word {
+        return 4242     ; TODO
+    }
+
+    sub sin16u(ubyte angle) -> uword {
+        return 4242     ; TODO
+    }
+
+    sub cos16u(ubyte angle) -> uword {
+        return 4242     ; TODO
+    }
+
+    sub sinr8u(ubyte radians) -> ubyte {
+        ubyte[180] sintab = [
+            $80, $84, $88, $8d,
+            $91, $96, $9a, $9e, $a3, $a7, $ab, $af, $b3, $b7, $bb, $bf, $c3, $c7, $ca, $ce,
+            $d1, $d5, $d8, $db, $de, $e1, $e4, $e7, $e9, $ec, $ee, $f0, $f2, $f4, $f6, $f7,
+            $f9, $fa, $fb, $fc, $fd, $fe, $fe, $ff, $ff, $ff, $ff, $ff, $fe, $fe, $fd, $fc,
+            $fb, $fa, $f9, $f7, $f6, $f4, $f2, $f0, $ee, $ec, $e9, $e7, $e4, $e1, $de, $db,
+            $d8, $d5, $d1, $ce, $ca, $c7, $c3, $bf, $bb, $b7, $b3, $af, $ab, $a7, $a3, $9e,
+            $9a, $96, $91, $8d, $88, $84, $80, $7b, $77, $72, $6e, $69, $65, $61, $5c, $58,
+            $54, $50, $4c, $48, $44, $40, $3c, $38, $35, $31, $2e, $2a, $27, $24, $21, $1e,
+            $1b, $18, $16, $13, $11, $0f, $0d, $0b, $09, $08, $06, $05, $04, $03, $02, $01,
+            $01, $00, $00, $00, $00, $00, $01, $01, $02, $03, $04, $05, $06, $08, $09, $0b,
+            $0d, $0f, $11, $13, $16, $18, $1b, $1e, $21, $24, $27, $2a, $2e, $31, $35, $38,
+            $3c, $40, $44, $48, $4c, $50, $54, $58, $5c, $61, $65, $69, $6e, $72, $77, $7b]
+        return sintab[radians]
+    }
+
+    sub cosr8u(ubyte radians) -> ubyte {
+        ubyte[180] costab = [
+            $ff, $ff, $ff, $fe, $fe, $fd, $fc,
+            $fb, $fa, $f9, $f7, $f6, $f4, $f2, $f0, $ee, $ec, $e9, $e7, $e4, $e1, $de, $db,
+            $d8, $d5, $d1, $ce, $ca, $c7, $c3, $bf, $bb, $b7, $b3, $af, $ab, $a7, $a3, $9e,
+            $9a, $96, $91, $8d, $88, $84, $80, $7b, $77, $72, $6e, $69, $65, $61, $5c, $58,
+            $54, $50, $4c, $48, $44, $40, $3c, $38, $35, $31, $2e, $2a, $27, $24, $21, $1e,
+            $1b, $18, $16, $13, $11, $0f, $0d, $0b, $09, $08, $06, $05, $04, $03, $02, $01,
+            $01, $00, $00, $00, $00, $00, $01, $01, $02, $03, $04, $05, $06, $08, $09, $0b,
+            $0d, $0f, $11, $13, $16, $18, $1b, $1e, $21, $24, $27, $2a, $2e, $31, $35, $38,
+            $3c, $40, $44, $48, $4c, $50, $54, $58, $5c, $61, $65, $69, $6e, $72, $77, $7b,
+            $7f, $84, $88, $8d, $91, $96, $9a, $9e, $a3, $a7, $ab, $af, $b3, $b7, $bb, $bf,
+            $c3, $c7, $ca, $ce, $d1, $d5, $d8, $db, $de, $e1, $e4, $e7, $e9, $ec, $ee, $f0,
+            $f2, $f4, $f6, $f7, $f9, $fa, $fb, $fc, $fd, $fe, $fe, $ff, $ff ]
+        return costab[radians]
+    }
+
+    sub sinr8(ubyte radians) -> byte {
+        return 42     ; TODO
+    }
+
+    sub cosr8(ubyte radians) -> byte {
+        return 42     ; TODO
+    }
+
+    sub sinr16(ubyte radians) -> word {
+        return 4242     ; TODO
+    }
+
+    sub cosr16(ubyte radians) -> word {
+        return 4242     ; TODO
+    }
+
+    sub sinr16u(ubyte radians) -> uword {
+        return 4242     ; TODO
+    }
+
+    sub cosr16u(ubyte radians) -> uword {
+        return 4242     ; TODO
+    }
 }
@@ -1,6 +1,4 @@
 ; Internal library routines - always included by the compiler
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0

 %import textio

@@ -37,4 +35,19 @@ prog8_lib {
        }
        return false
    }
+
+    sub string_compare(str st1, str st2) -> byte {
+        ; Compares two strings for sorting.
+        ; Returns -1 (255), 0 or 1 depending on wether string1 sorts before, equal or after string2.
+        ; Note that you can also directly compare strings and string values with eachother using
+        ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
+        %asm {{
+            loadm.w r0, {prog8_lib.string_compare.st1}
+            loadm.w r1, {prog8_lib.string_compare.st2}
+            syscall 29
+            return
+        }}
+    }
+
 }
+
@@ -0,0 +1,116 @@
+; 0-terminated string manipulation routines. For the Virtual Machine target.
+
+string {
+    sub length(str st) -> ubyte {
+        ; Returns the number of bytes in the string.
+        ; This value is determined during runtime and counts upto the first terminating 0 byte in the string,
+        ; regardless of the size of the string during compilation time. Don’t confuse this with len and sizeof!
+        ubyte count = 0
+        while st[count]
+            count++
+        return count
+    }
+
+    sub left(str source, ubyte slen, str target)  {
+        ; Copies the left side of the source string of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        target[slen] = 0
+        ubyte ix
+        for ix in 0 to slen-1 {
+            target[ix] = source[ix]
+        }
+    }
+
+    sub right(str source, ubyte slen, str target) {
+        ; Copies the right side of the source string of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that length is smaller or equal to the length of the source string.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        ubyte offset = length(source)-slen
+        ubyte ix
+        for ix in 0 to slen-1 {
+            target[ix] = source[ix+offset]
+        }
+        target[ix]=0
+    }
+
+    sub slice(str source, ubyte start, ubyte slen, str target) {
+        ; Copies a segment from the source string, starting at the given index,
+        ;  and of the given length to target string.
+        ; It is assumed the target string buffer is large enough to contain the result.
+        ; Also, you have to make sure yourself that start and length are within bounds of the strings.
+        ; Modifies in-place, doesn’t return a value (so can’t be used in an expression).
+        ubyte ix
+        for ix in 0 to slen-1 {
+            target[ix] = source[ix+start]
+        }
+        target[ix]=0
+    }
+
+    sub find(str st, ubyte character) -> ubyte {
+        ; Locates the first position of the given character in the string,
+        ; returns Carry set if found + index in A, or Carry clear if not found.
+        ubyte ix
+        for ix in 0 to length(st)-1 {
+            if st[ix]==character {
+                sys.set_carry()
+                return ix
+            }
+        }
+        sys.clear_carry()
+        return 0
+    }
+
+    sub copy(str source, str target) -> ubyte {
+        ; Copy a string to another, overwriting that one.
+        ; Returns the length of the string that was copied.
+        ; Often you don’t have to call this explicitly and can just write string1 = string2
+        ; but this function is useful if you’re dealing with addresses for instance.
+        ubyte ix
+        repeat {
+            ubyte char=source[ix]
+            target[ix]=char
+            if not char
+                return ix
+            ix++
+        }
+    }
+
+    sub compare(str st1, str st2) -> byte {
+        ; Compares two strings for sorting.
+        ; Returns -1 (255), 0 or 1 depending on wether string1 sorts before, equal or after string2.
+        ; Note that you can also directly compare strings and string values with eachother using
+        ; comparison operators ==, < etcetera (it will use strcmp for you under water automatically).
+        return prog8_lib.string_compare(st1, st2)
+    }
+
+    sub lower(str st) -> ubyte {
+        ; Lowercases the petscii string in-place. Returns length of the string.
+        ; (for efficiency, non-letter characters > 128 will also not be left intact,
+        ;  but regular text doesn't usually contain those characters anyway.)
+        ubyte ix
+        repeat {
+            ubyte char=st[ix]
+            if not char
+                return ix
+            if char >= 'A' and char <= 'Z'
+                st[ix] = char | %00100000
+            ix++
+        }
+    }
+
+    sub upper(str st) -> ubyte {
+        ; Uppercases the petscii string in-place. Returns length of the string.
+        ubyte ix
+        repeat {
+            ubyte char=st[ix]
+            if not char
+                return ix
+            if char >= 97 and char <= 122
+                st[ix] = char & %11011111
+            ix++
+        }
+    }
+}
@@ -1,62 +1,47 @@
 ; Prog8 definitions for the Virtual Machine
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-;

 sys {
    ; ------- lowlevel system routines --------

    const ubyte target = 255         ;  compilation target specifier.  64 = C64, 128 = C128,  16 = CommanderX16, 8 = atari800XL, 255 = virtual

-    ; SYSCALLS
-    ; 0 = reset ; resets system
-    ; 1 = exit ; stops program and returns statuscode from r0.w
-    ; 2 = print_c ; print single character
-    ; 3 = print_s ; print 0-terminated string from memory
-    ; 4 = print_u8 ; print unsigned int byte
-    ; 5 = print_u16 ; print unsigned int word
-    ; 6 = input ; reads a line of text entered by the user, r0.w = memory buffer, r1.b = maxlength (0-255, 0=unlimited).  Zero-terminates the string. Returns length in r65535.w
-    ; 7 = sleep ; sleep amount of milliseconds
-    ; 8 = gfx_enable  ; enable graphics window  r0.b = 0 -> lores 320x240,  r0.b = 1 -> hires 640x480
-    ; 9 = gfx_clear   ; clear graphics window with shade in r0.b
-    ; 10 = gfx_plot   ; plot pixel in graphics window, r0.w/r1.w contain X and Y coordinates, r2.b contains brightness
-
-    const ubyte SC_RESET = 0
-    const ubyte SC_EXIT = 1
-    const ubyte SC_PRINT_C = 2
-    const ubyte SC_PRINT_S = 3
-    const ubyte SC_PRINT_U8 = 4
-    const ubyte SC_PRINT_u16 = 5
-    const ubyte SC_INPUT = 6
-    const ubyte SC_SLEEP = 7
-    const ubyte SC_GFX_ENABLE = 8
-    const ubyte SC_GFX_CLEAR = 9
-    const ubyte SC_GFX_PLOT = 10
-    const ubyte SC_RND = 11
-    const ubyte SC_WAIT = 12
-    const ubyte SC_WAITVSYNC = 13
-
-
    sub  reset_system()  {
        ; Soft-reset the system back to initial power-on Basic prompt.
-        syscall(SC_RESET)
+        %asm {{
+            syscall 0
+        }}
    }

    sub wait(uword jiffies) {
        ; --- wait approximately the given number of jiffies (1/60th seconds)
-        syscall1(SC_WAIT, jiffies)
+        %asm {{
+            loadm.w r0, {sys.wait.jiffies}
+            syscall 13
+        }}
    }

    sub waitvsync() {
        ; --- busy wait till the next vsync has occurred (approximately), without depending on custom irq handling.
-        syscall(SC_WAITVSYNC)
+        %asm {{
+            syscall 14
+        }}
    }

-    sub memcopy(uword source, uword target, uword count)  {
-        repeat count {
-            @(target) = @(source)
+    sub internal_stringcopy(uword source, uword tgt) {
+        ; Called when the compiler wants to assign a string value to another string.
+        while @(source) {
+            @(tgt) = @(source)
            source++
-            target++
+            tgt++
+        }
+        @(tgt)=0
+    }
+
+    sub memcopy(uword source, uword tgt, uword count)  {
+        repeat count {
+            @(tgt) = @(source)
+            source++
+            tgt++
        }
    }

@@ -76,7 +61,48 @@ sys {

    sub exit(ubyte returnvalue) {
        ; -- immediately exit the program with a return code in the A register
-        syscall1(SC_EXIT, returnvalue)
+        %asm {{
+            loadm.b r0,{sys.exit.returnvalue}
+            syscall 1
+        }}
+    }
+
+    sub set_carry() {
+        %asm {{
+            sec
+        }}
+    }
+
+    sub clear_carry() {
+        %asm {{
+            clc
+        }}
+    }
+
+
+    sub gfx_enable(ubyte mode) {
+        %asm {{
+            loadm.b r0, {sys.gfx_enable.mode}
+            syscall 8
+        }}
+    }
+
+    sub gfx_plot(uword xx, uword yy, ubyte color) {
+        %asm {{
+            loadm.w r0, {sys.gfx_plot.xx}
+            loadm.w r1, {sys.gfx_plot.yy}
+            loadm.b r2, {sys.gfx_plot.color}
+            syscall 10
+        }}
+    }
+
+    sub gfx_getpixel(uword xx, uword yy) -> ubyte {
+        %asm {{
+            loadm.w r0, {sys.gfx_getpixel.xx}
+            loadm.w r1, {sys.gfx_getpixel.yy}
+            syscall 30
+            return
+        }}
    }
 }

@@ -84,7 +110,6 @@ cx16 {

    ; the sixteen virtual 16-bit registers that the CX16 has defined in the zeropage
    ; they are simulated on the VirtualMachine as well but their location in memory is different
-; the sixteen virtual 16-bit registers in both normal unsigned mode and signed mode (s)
    &uword r0  = $0002
    &uword r1  = $0004
    &uword r2  = $0006
@@ -1,14 +1,15 @@
 ; Prog8 definitions for the Text I/O console routines for the Virtual Machine
-;
-; Written by Irmen de Jong (irmen@razorvine.net) - license: GNU GPL 3.0
-
-%import syslib

+%import conv

 txt {

 sub  clear_screen() {
-    syscall1(3, "\x1b[2J\x1B[H")
+    str @shared sequence = "\x1b[2J\x1B[H"
+    %asm {{
+        load.w r0, {txt.clear_screen.sequence}
+        syscall 3
+    }}
 }

 sub nl() {
@@ -28,144 +29,95 @@ sub uppercase() {
 }

 sub chrout(ubyte char) {
-    syscall1(2, char)
+    %asm {{
+        loadm.b r0, {txt.chrout.char}
+        syscall 2
+    }}
 }

 sub  print (str text) {
-    syscall1(3, text)
+    %asm {{
+        loadm.w r0, {txt.print.text}
+        syscall 3
+    }}
 }

 sub  print_ub0  (ubyte value) {
    ; ---- print the ubyte in A in decimal form, with left padding 0s (3 positions total)
-    ; TODO use conv module?
-    ubyte hundreds = value / 100
-    value -= hundreds*100
-    ubyte tens = value / 10
-    value -= tens*10
-    chrout(hundreds+'0')
-    chrout(tens+'0')
-    chrout(value+'0')
+    conv.str_ub0(value)
+    print(conv.string_out)
 }

 sub  print_ub  (ubyte value)  {
    ; ---- print the ubyte in decimal form, without left padding 0s
-    ; TODO use conv module?
-    ubyte hundreds = value / 100
-    value -= hundreds*100
-    ubyte tens = value / 10
-    value -= tens*10
-    if hundreds
-        goto print_hundreds
-    if tens
-        goto print_tens
-    goto print_ones
-print_hundreds:
-    chrout(hundreds+'0')
-print_tens:
-    chrout(tens+'0')
-print_ones:
-    chrout(value+'0')
+    conv.str_ub(value)
+    print(conv.string_out)
 }

 sub  print_b  (byte value)   {
    ; ---- print the byte in decimal form, without left padding 0s
-    if value<0 {
-        chrout('-')
-        value = -value
-    }
-    print_ub(value as ubyte)
+    conv.str_b(value)
+    print(conv.string_out)
 }

-str hex_digits = "0123456789abcdef"
-
 sub  print_ubhex  (ubyte value, ubyte prefix)  {
    ; ---- print the ubyte in hex form
    if prefix
        chrout('$')
-
-    chrout(hex_digits[value>>4])
-    chrout(hex_digits[value&15])
+    conv.str_ubhex(value)
+    print(conv.string_out)
 }

 sub  print_ubbin  (ubyte value, ubyte prefix) {
    ; ---- print the ubyte in binary form
-    ; TODO use conv module?
+    if prefix
+        chrout('%')
+    conv.str_ubbin(value)
+    print(conv.string_out)
 }

 sub  print_uwbin  (uword value, ubyte prefix)  {
    ; ---- print the uword in binary form
-    ; TODO use conv module?
+    if prefix
+        chrout('%')
+    conv.str_uwbin(value)
+    print(conv.string_out)
 }

 sub  print_uwhex  (uword value, ubyte prefix) {
    ; ---- print the uword in hexadecimal form (4 digits)
-    print_ubhex(msb(value), true)
-    print_ubhex(lsb(value), false)
+    if prefix
+        chrout('$')
+    conv.str_uwhex(value)
+    print(conv.string_out)
 }

 sub  print_uw0  (uword value)  {
    ; ---- print the uword value in decimal form, with left padding 0s (5 positions total)
-    ; TODO use conv module?
-    ubyte tenthousands = (value / 10000) as ubyte
-    value -= 10000*tenthousands
-    ubyte thousands = (value / 1000) as ubyte
-    value -= 1000*thousands
-    ubyte hundreds = (value / 100) as ubyte
-    value -= 100 as uword * hundreds
-    ubyte tens = (value / 10) as ubyte
-    value -= 10*tens
-    chrout(tenthousands+'0')
-    chrout(thousands+'0')
-    chrout(hundreds+'0')
-    chrout(tens+'0')
-    chrout(value as ubyte + '0')
+    conv.str_uw0(value)
+    print(conv.string_out)
 }

 sub  print_uw  (uword value)  {
    ; ---- print the uword in decimal form, without left padding 0s
-    ubyte tenthousands = (value / 10000) as ubyte
-    value -= 10000*tenthousands
-    ubyte thousands = (value / 1000) as ubyte
-    value -= 1000*thousands
-    ubyte hundreds = (value / 100) as ubyte
-    value -= 100 as uword * hundreds
-    ubyte tens = (value / 10) as ubyte
-    value -= 10*tens
-    if tenthousands
-        goto print_tenthousands
-    if thousands
-        goto print_thousands
-    if hundreds
-        goto print_hundreds
-    if tens
-        goto print_tens
-    goto print_ones
-print_tenthousands:
-    chrout(tenthousands+'0')
-print_thousands:
-    chrout(thousands+'0')
-print_hundreds:
-    chrout(hundreds+'0')
-print_tens:
-    chrout(tens+'0')
-print_ones:
-    chrout(value as ubyte + '0')
+    conv.str_uw(value)
+    print(conv.string_out)
 }

 sub  print_w  (word value) {
    ; ---- print the (signed) word in decimal form, without left padding 0's
-    if value<0 {
-        chrout('-')
-        value = -value
-    }
-    print_uw(value as uword)
+    conv.str_w(value)
+    print(conv.string_out)
 }

 sub  input_chars  (uword buffer) -> ubyte  {
    ; ---- Input a string (max. 80 chars) from the keyboard. Returns length of input. (string is terminated with a 0 byte as well)
    ;      It assumes the keyboard is selected as I/O channel!
-    ;  TODO
-    return 0
+    %asm {{
+        loadm.w r0,{txt.input_chars.buffer}
+        syscall 6
+        return
+    }}
 }

 }
@@ -1 +1 @@
-8.0
+8.3.1
@@ -1 +1 @@
 .0
 .3.1