From b8816a0e2f7cd1d6fecdcd96c20f20441ca57ff8 Mon Sep 17 00:00:00 2001
From: Irmen de Jong <irmen@razorvine.net>
Date: Fri, 7 Feb 2020 20:47:38 +0100
Subject: [PATCH] got rid of separate str_s datatype

---
 .idea/misc.xml                                |  16 +
 compiler/src/prog8/ast/AstToSourceCode.kt     |   3 +-
 compiler/src/prog8/ast/base/Base.kt           |   8 +-
 .../prog8/ast/expressions/AstExpressions.kt   |   3 +-
 .../prog8/ast/expressions/InferredTypes.kt    |   1 -
 .../src/prog8/ast/processing/AstChecker.kt    |  45 +-
 .../VarInitValueAndAddressOfCreator.kt        |   4 +-
 .../compiler/target/c64/codegen/AsmGen.kt     |  28 +-
 .../target/c64/codegen/AssignmentAsmGen.kt    |   4 +-
 .../c64/codegen/BuiltinFunctionsAsmGen.kt     |   4 +-
 .../target/c64/codegen/ExpressionsAsmGen.kt   |   6 +-
 .../target/c64/codegen/ForLoopsAsmGen.kt      |   2 +-
 .../target/c64/codegen/FunctionCallAsmGen.kt  |   4 +-
 .../target/c64/codegen/PostIncrDecrAsmGen.kt  |   2 +-
 .../src/prog8/functions/BuiltinFunctions.kt   |  13 +-
 .../src/prog8/optimizer/ConstantFolding.kt    |   7 +-
 compiler/src/prog8/vm/RuntimeValue.kt         |   8 +-
 compiler/src/prog8/vm/astvm/AstVm.kt          |  14 +-
 compiler/src/prog8/vm/astvm/Expressions.kt    |   1 -
 docs/source/programming.rst                   |   5 +-
 docs/source/syntaxreference.rst               |   2 -
 examples/screencodes.p8                       |  26 +
 examples/testarrays.p8                        |  15 +-
 parser/antlr/prog8.g4                         |   2 +-
 parser/src/prog8/parser/prog8Lexer.java       | 625 +++++++++---------
 parser/src/prog8/parser/prog8Parser.java      | 616 +++++++++--------
 26 files changed, 721 insertions(+), 743 deletions(-)
 create mode 100644 examples/screencodes.p8

diff --git a/.idea/misc.xml b/.idea/misc.xml
index 479418d30..998cdfe24 100644
--- a/.idea/misc.xml
+++ b/.idea/misc.xml
@@ -1,5 +1,21 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
+  <component name="ANTLRGenerationPreferences">
+    <option name="perGrammarGenerationSettings">
+      <list>
+        <PerGrammarGenerationSettings>
+          <option name="fileName" value="$PROJECT_DIR$/parser/antlr/prog8.g4" />
+          <option name="autoGen" value="true" />
+          <option name="outputDir" value="$PROJECT_DIR$/parser/src/prog8/parser" />
+          <option name="libDir" value="" />
+          <option name="encoding" value="" />
+          <option name="pkg" value="" />
+          <option name="language" value="" />
+          <option name="generateListener" value="false" />
+        </PerGrammarGenerationSettings>
+      </list>
+    </option>
+  </component>
   <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
     <output url="file://$PROJECT_DIR$/out" />
   </component>
diff --git a/compiler/src/prog8/ast/AstToSourceCode.kt b/compiler/src/prog8/ast/AstToSourceCode.kt
index 64f54c058..7c54c2f17 100644
--- a/compiler/src/prog8/ast/AstToSourceCode.kt
+++ b/compiler/src/prog8/ast/AstToSourceCode.kt
@@ -3,7 +3,6 @@ package prog8.ast
 import prog8.ast.antlr.escape
 import prog8.ast.base.DataType
 import prog8.ast.base.NumericDatatypes
-import prog8.ast.base.StringDatatypes
 import prog8.ast.base.VarDeclType
 import prog8.ast.expressions.*
 import prog8.ast.processing.IAstVisitor
@@ -79,7 +78,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
     private fun datatypeString(dt: DataType): String {
         return when(dt) {
             in NumericDatatypes -> dt.toString().toLowerCase()
-            in StringDatatypes -> dt.toString().toLowerCase()
+            DataType.STR -> dt.toString().toLowerCase()
             DataType.ARRAY_UB -> "ubyte["
             DataType.ARRAY_B -> "byte["
             DataType.ARRAY_UW -> "uword["
diff --git a/compiler/src/prog8/ast/base/Base.kt b/compiler/src/prog8/ast/base/Base.kt
index cb19224f9..cfe40de75 100644
--- a/compiler/src/prog8/ast/base/Base.kt
+++ b/compiler/src/prog8/ast/base/Base.kt
@@ -13,7 +13,6 @@ enum class DataType {
     WORD,               // pass by value
     FLOAT,              // pass by value
     STR,                // pass by reference
-    STR_S,              // pass by reference
     ARRAY_UB,           // pass by reference
     ARRAY_B,            // pass by reference
     ARRAY_UW,           // pass by reference
@@ -32,8 +31,7 @@ enum class DataType {
                 UWORD -> targetType in setOf(UWORD, FLOAT)
                 WORD -> targetType in setOf(WORD, FLOAT)
                 FLOAT -> targetType == FLOAT
-                STR -> targetType == STR || targetType==STR_S
-                STR_S -> targetType == STR || targetType==STR_S
+                STR -> targetType == STR
                 in ArrayDatatypes -> targetType == this
                 else -> false
             }
@@ -113,10 +111,9 @@ val ByteDatatypes = setOf(DataType.UBYTE, DataType.BYTE)
 val WordDatatypes = setOf(DataType.UWORD, DataType.WORD)
 val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
 val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
-val StringDatatypes = setOf(DataType.STR, DataType.STR_S)
 val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
 val IterableDatatypes = setOf(
-        DataType.STR, DataType.STR_S,
+        DataType.STR,
         DataType.ARRAY_UB, DataType.ARRAY_B,
         DataType.ARRAY_UW, DataType.ARRAY_W,
         DataType.ARRAY_F)
@@ -124,7 +121,6 @@ val PassByValueDatatypes = NumericDatatypes
 val PassByReferenceDatatypes = IterableDatatypes.plus(DataType.STRUCT)
 val ArrayElementTypes = mapOf(
         DataType.STR to DataType.UBYTE,
-        DataType.STR_S to DataType.UBYTE,
         DataType.ARRAY_B to DataType.BYTE,
         DataType.ARRAY_UB to DataType.UBYTE,
         DataType.ARRAY_W to DataType.WORD,
diff --git a/compiler/src/prog8/ast/expressions/AstExpressions.kt b/compiler/src/prog8/ast/expressions/AstExpressions.kt
index 992c13c05..5d692e5e3 100644
--- a/compiler/src/prog8/ast/expressions/AstExpressions.kt
+++ b/compiler/src/prog8/ast/expressions/AstExpressions.kt
@@ -197,7 +197,7 @@ class ArrayIndexedExpression(var identifier: IdentifierReference,
         val target = identifier.targetStatement(program.namespace)
         if (target is VarDecl) {
             return when (target.datatype) {
-                in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE)
+                DataType.STR -> InferredTypes.knownFor(DataType.UBYTE)
                 in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(target.datatype))
                 else -> InferredTypes.unknown()
             }
@@ -524,7 +524,6 @@ class RangeExpr(var from: Expression,
             fromDt istype DataType.UBYTE && toDt istype DataType.UBYTE -> InferredTypes.knownFor(DataType.ARRAY_UB)
             fromDt istype DataType.UWORD && toDt istype DataType.UWORD -> InferredTypes.knownFor(DataType.ARRAY_UW)
             fromDt istype DataType.STR && toDt istype DataType.STR -> InferredTypes.knownFor(DataType.STR)
-            fromDt istype DataType.STR_S && toDt istype DataType.STR_S -> InferredTypes.knownFor(DataType.STR_S)
             fromDt istype DataType.WORD || toDt istype DataType.WORD -> InferredTypes.knownFor(DataType.ARRAY_W)
             fromDt istype DataType.BYTE || toDt istype DataType.BYTE -> InferredTypes.knownFor(DataType.ARRAY_B)
             else -> InferredTypes.knownFor(DataType.ARRAY_UB)
diff --git a/compiler/src/prog8/ast/expressions/InferredTypes.kt b/compiler/src/prog8/ast/expressions/InferredTypes.kt
index d6b3bb312..a11b4ff48 100644
--- a/compiler/src/prog8/ast/expressions/InferredTypes.kt
+++ b/compiler/src/prog8/ast/expressions/InferredTypes.kt
@@ -46,7 +46,6 @@ object InferredTypes {
             DataType.WORD to InferredType.known(DataType.WORD),
             DataType.FLOAT to InferredType.known(DataType.FLOAT),
             DataType.STR to InferredType.known(DataType.STR),
-            DataType.STR_S to InferredType.known(DataType.STR_S),
             DataType.ARRAY_UB to InferredType.known(DataType.ARRAY_UB),
             DataType.ARRAY_B to InferredType.known(DataType.ARRAY_B),
             DataType.ARRAY_UW to InferredType.known(DataType.ARRAY_UW),
diff --git a/compiler/src/prog8/ast/processing/AstChecker.kt b/compiler/src/prog8/ast/processing/AstChecker.kt
index c368c7de0..998910d03 100644
--- a/compiler/src/prog8/ast/processing/AstChecker.kt
+++ b/compiler/src/prog8/ast/processing/AstChecker.kt
@@ -1,5 +1,3 @@
-@file:Suppress("DuplicatedCode")
-
 package prog8.ast.processing
 
 import prog8.ast.IFunctionCall
@@ -125,7 +123,7 @@ internal class AstChecker(private val program: Program,
         } else {
             if (forLoop.loopRegister != null) {
                 // loop register
-                if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt !in StringDatatypes)
+                if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt != DataType.STR)
                     checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position))
                 if(forLoop.loopRegister!=Register.A)
                     checkResult.add(ExpressionError("it's only possible to use A as a loop register", forLoop.position))
@@ -137,11 +135,11 @@ internal class AstChecker(private val program: Program,
                 } else {
                     when (loopvar.datatype) {
                         DataType.UBYTE -> {
-                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt !in StringDatatypes)
+                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
                                 checkResult.add(ExpressionError("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position))
                         }
                         DataType.UWORD -> {
-                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt !in StringDatatypes &&
+                            if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt != DataType.STR &&
                                     iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
                                 checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position))
                         }
@@ -245,7 +243,7 @@ internal class AstChecker(private val program: Program,
                 }
                 else if(param.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
                     if (param.first.type != DataType.UWORD && param.first.type != DataType.WORD
-                            && param.first.type !in StringDatatypes && param.first.type !in ArrayDatatypes && param.first.type != DataType.FLOAT)
+                            && param.first.type != DataType.STR && param.first.type !in ArrayDatatypes && param.first.type != DataType.FLOAT)
                         err("parameter '${param.first.name}' should be (u)word/address")
                 }
                 else if(param.second.statusflag!=null) {
@@ -260,7 +258,7 @@ internal class AstChecker(private val program: Program,
                 }
                 else if(ret.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
                     if (ret.first.value != DataType.UWORD && ret.first.value != DataType.WORD
-                            && ret.first.value !in StringDatatypes && ret.first.value !in ArrayDatatypes && ret.first.value != DataType.FLOAT)
+                            && ret.first.value != DataType.STR && ret.first.value !in ArrayDatatypes && ret.first.value != DataType.FLOAT)
                         err("return value #${ret.first.index + 1} should be (u)word/address")
                 }
                 else if(ret.second.statusflag!=null) {
@@ -411,7 +409,7 @@ internal class AstChecker(private val program: Program,
             }
         }
         val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
-        if(targetDt in StringDatatypes || targetDt in ArrayDatatypes)
+        if(targetDt in IterableDatatypes)
             checkResult.add(SyntaxError("cannot assign to a string or array type", assignTarget.position))
 
         if (assignment is Assignment) {
@@ -447,7 +445,7 @@ internal class AstChecker(private val program: Program,
         if(variable==null)
             checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", addressOf.position))
         else {
-            if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes && variable.datatype!=DataType.STRUCT)
+            if(variable.datatype !in ArrayDatatypes && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
                 checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position))
         }
         super.visit(addressOf)
@@ -876,10 +874,10 @@ internal class AstChecker(private val program: Program,
                         checkResult.add(ExpressionError("swap requires args of numerical type", position))
                 }
                 else if(target.name=="all" || target.name=="any") {
-                    if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype in StringDatatypes) {
+                    if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype == DataType.STR) {
                         checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
                     }
-                    if(args[0].inferType(program).typeOrElse(DataType.STR) in StringDatatypes) {
+                    if(args[0].inferType(program).typeOrElse(DataType.STR) == DataType.STR) {
                         checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
                     }
                 }
@@ -896,7 +894,7 @@ internal class AstChecker(private val program: Program,
                     val argDt=argIDt.typeOrElse(DataType.STRUCT)
                     if(!(argDt isAssignableTo arg.second.type)) {
                         // for asm subroutines having STR param it's okay to provide a UWORD (address value)
-                        if(!(target.isAsmSubroutine && arg.second.type in StringDatatypes && argDt == DataType.UWORD))
+                        if(!(target.isAsmSubroutine && arg.second.type == DataType.STR && argDt == DataType.UWORD))
                             checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position))
                     }
 
@@ -963,7 +961,7 @@ internal class AstChecker(private val program: Program,
                 val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
                 if(index!=null && (index<0 || index>=arraysize))
                     checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position))
-            } else if(target.datatype in StringDatatypes) {
+            } else if(target.datatype == DataType.STR) {
                 if(target.value is StringLiteralValue) {
                     // check string lengths for non-memory mapped strings
                     val stringLen = (target.value as StringLiteralValue).value.length
@@ -1047,19 +1045,15 @@ internal class AstChecker(private val program: Program,
     }
 
     private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteralValue) : Boolean {
-        fun err(msg: String): Boolean {
-            checkResult.add(ExpressionError(msg, value.position))
-            return false
-        }
-        return when (targetDt) {
-            in StringDatatypes -> {
-                return if (value.value.length > 255)
-                    err("string length must be 0-255")
-                else
-                    true
+        return if (targetDt == DataType.STR) {
+            if (value.value.length > 255) {
+                checkResult.add(ExpressionError("string length must be 0-255", value.position))
+                false
             }
-            else -> false
+            else
+                true
         }
+        else false
     }
 
     private fun checkValueTypeAndRangeArray(targetDt: DataType, struct: StructDecl?,
@@ -1069,7 +1063,7 @@ internal class AstChecker(private val program: Program,
             return false
         }
         when (targetDt) {
-            in StringDatatypes -> return err("string value expected")
+            DataType.STR -> return err("string value expected")
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
                 // value may be either a single byte, or a byte arraysize (of all constant values), or a range
                 if(value.type==targetDt) {
@@ -1276,7 +1270,6 @@ internal class AstChecker(private val program: Program,
             DataType.UWORD -> sourceDatatype== DataType.UBYTE || sourceDatatype== DataType.UWORD
             DataType.FLOAT -> sourceDatatype in NumericDatatypes
             DataType.STR -> sourceDatatype== DataType.STR
-            DataType.STR_S -> sourceDatatype== DataType.STR_S
             DataType.STRUCT -> {
                 if(sourceDatatype==DataType.STRUCT) {
                     val structLv = sourceValue as StructLiteralValue
diff --git a/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt b/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt
index b568d4ed2..f0281102b 100644
--- a/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt
+++ b/compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt
@@ -103,14 +103,14 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA
     private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<Expression>, parent: Statement) {
         // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
         for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
-            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) {
+            if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type == DataType.STR) {
                 if(argparam.second is AddressOf)
                     continue
                 val idref = argparam.second as? IdentifierReference
                 val strvalue = argparam.second as? StringLiteralValue
                 if(idref!=null) {
                     val variable = idref.targetVarDecl(program.namespace)
-                    if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) {
+                    if(variable!=null && variable.datatype in IterableDatatypes) {
                         val pointerExpr = AddressOf(idref, idref.position)
                         pointerExpr.linkParents(arglist[argparam.first.index].parent)
                         arglist[argparam.first.index] = pointerExpr
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
index 905f81bc1..190f74e31 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
@@ -206,18 +206,9 @@ internal class AsmGen(private val program: Program,
         return "$b0, $b1, $b2, $b3, $b4"
     }
 
-    private fun encodeStr(str: String, dt: DataType): List<Short> {
-        return when(dt) {
-            DataType.STR -> {
-                val bytes = Petscii.encodePetscii(str, true)
-                bytes.plus(0)
-            }
-            DataType.STR_S -> {
-                val bytes = Petscii.encodeScreencode(str, true)
-                bytes.plus(0)
-            }
-            else -> throw AssemblyError("invalid str type")
-        }
+    private fun encodeStr(str: String): List<Short> {
+         val bytes = Petscii.encodePetscii(str, true)
+         return bytes.plus(0)
     }
 
     private fun zeropagevars2asm(statements: List<Statement>) {
@@ -254,10 +245,9 @@ internal class AsmGen(private val program: Program,
             DataType.WORD -> out("${decl.name}\t.sint  0")
             DataType.FLOAT -> out("${decl.name}\t.byte  0,0,0,0,0  ; float")
             DataType.STRUCT -> {}       // is flattened
-            DataType.STR, DataType.STR_S -> {
+            DataType.STR -> {
                 val string = (decl.value as StringLiteralValue).value
-                val encoded = encodeStr(string, decl.datatype)
-                outputStringvar(decl, encoded)
+                outputStringvar(decl, encodeStr(string))
             }
             DataType.ARRAY_UB -> {
                 val data = makeArrayFillDataUnsigned(decl)
@@ -340,8 +330,8 @@ internal class AsmGen(private val program: Program,
 
         // special treatment for string types: merge strings that are identical
         val encodedstringVars = normalVars
-                .filter {it.datatype in StringDatatypes }
-                .map { it to encodeStr((it.value as StringLiteralValue).value, it.datatype) }
+                .filter {it.datatype == DataType.STR }
+                .map { it to encodeStr((it.value as StringLiteralValue).value) }
                 .groupBy({it.second}, {it.first})
         for((encoded, variables) in encodedstringVars) {
             variables.dropLast(1).forEach { out(it.name) }
@@ -350,7 +340,7 @@ internal class AsmGen(private val program: Program,
         }
 
         // non-string variables
-        normalVars.filter{ it.datatype !in StringDatatypes}.sortedBy { it.datatype }.forEach {
+        normalVars.filter{ it.datatype != DataType.STR }.sortedBy { it.datatype }.forEach {
             if(it.scopedname !in allocatedZeropageVariables)
                 vardecl2asm(it)
         }
@@ -510,7 +500,7 @@ internal class AsmGen(private val program: Program,
     internal fun readAndPushArrayvalueWithIndexA(arrayDt: DataType, variable: IdentifierReference) {
         val variablename = asmIdentifierName(variable)
         when (arrayDt) {
-            DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+            DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
                 out("  tay |  lda  $variablename,y |  sta  $ESTACK_LO_HEX,x |  dex")
             DataType.ARRAY_UW, DataType.ARRAY_W ->
                 out("  asl  a |  tay |  lda  $variablename,y |  sta  $ESTACK_LO_HEX,x |  lda  $variablename+1,y |  sta  $ESTACK_HI_HEX,x | dex")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt
index 13580737d..e0400f11d 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt
@@ -83,7 +83,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
                     val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier)
                     val indexValue = index.number.toInt() * ArrayElementTypes.getValue(arrayDt).memorySize()
                     when (arrayDt) {
-                        DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+                        DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
                             asmgen.out("  lda  $arrayVarName+$indexValue |  sta  $ESTACK_LO_HEX,x |  dex")
                         DataType.ARRAY_UW, DataType.ARRAY_W ->
                             asmgen.out("  lda  $arrayVarName+$indexValue |  sta  $ESTACK_LO_HEX,x |  lda  $arrayVarName+$indexValue+1 |  sta  $ESTACK_HI_HEX,x | dex")
@@ -730,7 +730,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
 
     private fun popAndWriteArrayvalueWithIndexA(arrayDt: DataType, variablename: String) {
         when (arrayDt) {
-            DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B ->
+            DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
                 asmgen.out("  tay |  inx |  lda  $ESTACK_LO_HEX,x  | sta  $variablename,y")
             DataType.ARRAY_UW, DataType.ARRAY_W ->
                 asmgen.out("  asl  a |  tay |  inx |  lda  $ESTACK_LO_HEX,x |  sta  $variablename,y |  lda  $ESTACK_HI_HEX,x |  sta $variablename+1,y")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
index 85c1d02ca..6dc2416fd 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
@@ -85,7 +85,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 outputPushAddressAndLenghtOfArray(fcall.arglist[0])
                 val dt = fcall.arglist.single().inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
-                    DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_ub")
+                    DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_ub")
                     DataType.ARRAY_B -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
                     DataType.ARRAY_UW -> asmgen.out("  jsr  prog8_lib.func_${functionName}_uw")
                     DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
@@ -97,7 +97,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
                 outputPushAddressAndLenghtOfArray(fcall.arglist[0])
                 val dt = fcall.arglist.single().inferType(program)
                 when (dt.typeOrElse(DataType.STRUCT)) {
-                    DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
+                    DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out("  jsr  prog8_lib.func_${functionName}_b")
                     DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out("  jsr  prog8_lib.func_${functionName}_w")
                     DataType.ARRAY_F -> asmgen.out("  jsr  c64flt.func_${functionName}_f")
                     else -> throw AssemblyError("weird type $dt")
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
index 3a68fa2dc..ad8b65125 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
@@ -172,12 +172,12 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
             DataType.UWORD, DataType.WORD -> {
                 asmgen.out("  lda  $varname  |  sta  $ESTACK_LO_HEX,x  |  lda  $varname+1 |  sta  $ESTACK_HI_HEX,x |  dex")
             }
-            in ArrayDatatypes, in StringDatatypes -> {
-                asmgen.out("  lda  #<$varname  |  sta  $ESTACK_LO_HEX,x  |  lda  #>$varname |  sta  $ESTACK_HI_HEX,x |  dex")
-            }
             DataType.FLOAT -> {
                 asmgen.out(" lda  #<$varname |  ldy  #>$varname|  jsr  c64flt.push_float")
             }
+            in IterableDatatypes -> {
+                asmgen.out("  lda  #<$varname  |  sta  $ESTACK_LO_HEX,x  |  lda  #>$varname |  sta  $ESTACK_HI_HEX,x |  dex")
+            }
             else -> throw AssemblyError("stack push weird variable type $expr")
         }
     }
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt
index 4cc089ee5..98daa53b3 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt
@@ -318,7 +318,7 @@ $endLabel       inx""")
         val iterableName = asmgen.asmIdentifierName(ident)
         val decl = ident.targetVarDecl(program.namespace)!!
         when(iterableDt) {
-            DataType.STR, DataType.STR_S -> {
+            DataType.STR -> {
                 if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
                     throw AssemblyError("can only use A")
                 asmgen.out("""
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
index e9e4046ae..d065cb78d 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
@@ -228,9 +228,9 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
 
         // we have a special rule for some types.
         // strings are assignable to UWORD, for example, and vice versa
-        if(argType in StringDatatypes && paramType==DataType.UWORD)
+        if(argType==DataType.STR && paramType==DataType.UWORD)
             return true
-        if(argType==DataType.UWORD && paramType in StringDatatypes)
+        if(argType==DataType.UWORD && paramType == DataType.STR)
             return true
 
         return false
diff --git a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
index dd0dfa722..8209958e5 100644
--- a/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
+++ b/compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
@@ -123,7 +123,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
     private fun incrDecrArrayvalueWithIndexA(incr: Boolean, arrayDt: DataType, arrayVarName: String) {
         asmgen.out("  stx  ${C64Zeropage.SCRATCH_REG_X} |  tax")
         when(arrayDt) {
-            DataType.STR, DataType.STR_S,
+            DataType.STR,
             DataType.ARRAY_UB, DataType.ARRAY_B -> {
                 asmgen.out(if(incr) "  inc  $arrayVarName,x" else "  dec  $arrayVarName,x")
             }
diff --git a/compiler/src/prog8/functions/BuiltinFunctions.kt b/compiler/src/prog8/functions/BuiltinFunctions.kt
index 0ae593431..128f81661 100644
--- a/compiler/src/prog8/functions/BuiltinFunctions.kt
+++ b/compiler/src/prog8/functions/BuiltinFunctions.kt
@@ -88,7 +88,7 @@ val BuiltinFunctions = mapOf(
                                                         BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
                                                         BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
                                                         BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
-    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", StringDatatypes)), DataType.UBYTE, ::builtinStrlen)
+    "strlen"      to FunctionSignature(true, listOf(BuiltinFunctionParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
 )
 
 fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
@@ -121,8 +121,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
             if(!idt.isKnown)
                 throw FatalAstException("couldn't determine type of iterable $arglist")
             return when(val dt = idt.typeOrElse(DataType.STRUCT)) {
-                in NumericDatatypes -> dt
-                in StringDatatypes -> dt
+                DataType.STR, in NumericDatatypes -> dt
                 in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
                 else -> throw FatalAstException("function '$function' requires one argument which is an iterable")
             }
@@ -145,8 +144,8 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
         }
         "max", "min" -> {
             when(val dt = datatypeFromIterableArg(args.single())) {
+                DataType.STR -> InferredTypes.knownFor(DataType.UBYTE)
                 in NumericDatatypes -> InferredTypes.knownFor(dt)
-                in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE)
                 in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(dt))
                 else -> InferredTypes.unknown()
             }
@@ -159,7 +158,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
                 DataType.ARRAY_UB, DataType.ARRAY_UW -> InferredTypes.knownFor(DataType.UWORD)
                 DataType.ARRAY_B, DataType.ARRAY_W -> InferredTypes.knownFor(DataType.WORD)
                 DataType.ARRAY_F -> InferredTypes.knownFor(DataType.FLOAT)
-                in StringDatatypes -> InferredTypes.knownFor(DataType.UWORD)
+                DataType.STR -> InferredTypes.knownFor(DataType.UWORD)
                 else -> InferredTypes.unknown()
             }
         }
@@ -232,7 +231,7 @@ private fun builtinStrlen(args: List<Expression>, position: Position, program: P
     if (args.size != 1)
         throw SyntaxError("strlen requires one argument", position)
     val argument = args[0].constValue(program) ?: throw NotConstArgumentException()
-    if(argument.type !in StringDatatypes)
+    if(argument.type != DataType.STR)
         throw SyntaxError("strlen must have string argument", position)
 
     throw NotConstArgumentException()       // this function is not considering the string argument a constant
@@ -269,7 +268,7 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
                 throw CompilerException("array length exceeds byte limit ${target.position}")
             NumericLiteralValue.optimalInteger(arraySize, args[0].position)
         }
-        in StringDatatypes -> {
+        DataType.STR -> {
             val refLv = target.value as StringLiteralValue
             if(refLv.value.length>255)
                 throw CompilerException("string length exceeds byte limit ${refLv.position}")
diff --git a/compiler/src/prog8/optimizer/ConstantFolding.kt b/compiler/src/prog8/optimizer/ConstantFolding.kt
index a89651323..110e767b8 100644
--- a/compiler/src/prog8/optimizer/ConstantFolding.kt
+++ b/compiler/src/prog8/optimizer/ConstantFolding.kt
@@ -63,12 +63,6 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                         return super.visit(decl)
                     }
                 }
-                in StringDatatypes -> {
-                    // nothing to do for strings
-                }
-                DataType.STRUCT -> {
-                    // struct defintions don't have anything else in them
-                }
                 DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
                     val numericLv = decl.value as? NumericLiteralValue
                     val rangeExpr = decl.value as? RangeExpr
@@ -154,6 +148,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
                 }
                 else -> {
                     // nothing to do for this type
+                    // this includes strings and structs
                 }
             }
         }
diff --git a/compiler/src/prog8/vm/RuntimeValue.kt b/compiler/src/prog8/vm/RuntimeValue.kt
index 089861a5e..ef361da55 100644
--- a/compiler/src/prog8/vm/RuntimeValue.kt
+++ b/compiler/src/prog8/vm/RuntimeValue.kt
@@ -577,13 +577,7 @@ class RuntimeValueString(type: DataType, val str: String, val heapId: Int?): Run
         }
     }
 
-    override fun toString(): String {
-        return when (type) {
-            DataType.STR -> "str:$str"
-            DataType.STR_S -> "str_s:$str"
-            else -> "???"
-        }
-    }
+    override fun toString(): String = if(type==DataType.STR) "str:$str"  else "???"
 
     override fun hashCode(): Int = Objects.hash(type, str)
 
diff --git a/compiler/src/prog8/vm/astvm/AstVm.kt b/compiler/src/prog8/vm/astvm/AstVm.kt
index ee26e1fd9..5348a776d 100644
--- a/compiler/src/prog8/vm/astvm/AstVm.kt
+++ b/compiler/src/prog8/vm/astvm/AstVm.kt
@@ -577,7 +577,6 @@ class AstVm(val program: Program, compilationTarget: String) {
                         DataType.WORD -> mem.setSWord(address, (value as RuntimeValueNumeric).wordval!!)
                         DataType.FLOAT -> mem.setFloat(address, (value as RuntimeValueNumeric).floatval!!)
                         DataType.STR -> mem.setString(address, (value as RuntimeValueString).str)
-                        DataType.STR_S -> mem.setScreencodeString(address, (value as RuntimeValueString).str)
                         else -> throw VmExecutionException("weird memaddress type $decl")
                     }
                 } else
@@ -613,7 +612,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                             if (value.type != DataType.FLOAT)
                                 throw VmExecutionException("new value is of different datatype ${value.type} for $array")
                         }
-                        DataType.STR, DataType.STR_S -> {
+                        DataType.STR -> {
                             if (value.type !in ByteDatatypes)
                                 throw VmExecutionException("new value is of different datatype ${value.type} for $array")
                         }
@@ -621,7 +620,7 @@ class AstVm(val program: Program, compilationTarget: String) {
                     }
                     if (array.type in ArrayDatatypes)
                         (array as RuntimeValueArray).array[index.integerValue()] = value.numericValue()
-                    else if (array.type in StringDatatypes) {
+                    else if (array.type == DataType.STR) {
                         val indexInt = index.integerValue()
                         val newchr = value.numericValue().toChar().toString()
                         val newstr = (array as RuntimeValueString).str.replaceRange(indexInt, indexInt + 1, newchr)
@@ -783,13 +782,8 @@ class AstVm(val program: Program, compilationTarget: String) {
         return result
     }
 
-    private fun getAsciiStringFromRuntimeVars(heapId: Int): String {
-        val stringvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueString
-        return when (stringvar.type) {
-            DataType.STR, DataType.STR_S -> stringvar.str
-            else -> throw VmExecutionException("weird string type")
-        }
-    }
+    private fun getAsciiStringFromRuntimeVars(heapId: Int): String =
+            (runtimeVariables.getByHeapId(heapId) as RuntimeValueString).str
 
     private fun getArrayFromRuntimeVars(heapId: Int): IntArray {
         val arrayvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueArray
diff --git a/compiler/src/prog8/vm/astvm/Expressions.kt b/compiler/src/prog8/vm/astvm/Expressions.kt
index a5d6b239c..762b4ef63 100644
--- a/compiler/src/prog8/vm/astvm/Expressions.kt
+++ b/compiler/src/prog8/vm/astvm/Expressions.kt
@@ -125,7 +125,6 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase {
                             DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address))
                             DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address))
                             DataType.STR -> RuntimeValueString(DataType.STR, ctx.mem.getString(address), null)
-                            DataType.STR_S -> RuntimeValueString(DataType.STR_S, ctx.mem.getScreencodeString(address)!!, null)
                             else -> throw VmExecutionException("unexpected datatype $variable")
                         }
                     }
diff --git a/docs/source/programming.rst b/docs/source/programming.rst
index bef39ed59..1424830b0 100644
--- a/docs/source/programming.rst
+++ b/docs/source/programming.rst
@@ -271,9 +271,8 @@ Strings
 Strings are a sequence of characters enclosed in ``"`` quotes. The length is limited to 255 characters.
 They're stored and treated much the same as a byte array,
 but they have some special properties because they are considered to be *text*.
-Strings in your source code files will be encoded (translated from ASCII/UTF-8) into either CBM PETSCII or C-64 screencodes.
-PETSCII is the default choice. If you need screencodes (also called 'poke' codes) instead,
-you have to use the ``str_s`` variants of the string type identifier.
+Strings in your source code files will be encoded (translated from ASCII/UTF-8) into the byte-encoding
+that is used on the target platform. For the C-64, this is CBM PETSCII.
 
 You can concatenate two string literals using '+' (not very useful though) or repeat
 a string literal a given number of times using '*'::
diff --git a/docs/source/syntaxreference.rst b/docs/source/syntaxreference.rst
index 6aa6b5418..67256092e 100644
--- a/docs/source/syntaxreference.rst
+++ b/docs/source/syntaxreference.rst
@@ -268,8 +268,6 @@ type identifier  type                     storage size       example var declara
 ``float[]``      floating-point array     depends on value   ``float[] myvar = [1.1, 2.2, 3.3, 4.4]``
 ``str``          string (petscii)         varies             ``str myvar = "hello."``
                                                              implicitly terminated by a 0-byte
-``str_s``        string (screencodes)     varies             ``str_s myvar = "hello."``
-                                                             implicitly terminated by a 0-byte
 ===============  =======================  =================  =========================================
 
 **arrays:** you can split an array initializer list over several lines if you want. When an initialization
diff --git a/examples/screencodes.p8 b/examples/screencodes.p8
new file mode 100644
index 000000000..da9aa5173
--- /dev/null
+++ b/examples/screencodes.p8
@@ -0,0 +1,26 @@
+%import c64lib
+%import c64utils
+%zeropage basicsafe
+
+
+main {
+
+    sub start() {
+
+        c64.VMCSB |= 2  ; switch to lowercase charset
+
+        str s1 = "HELLO hello 1234 @[/]\n"
+        str s2 = "HELLO hello 1234 @[/]\n"   ; TODO as c64scr
+
+        c64scr.print("\n\n\n\nString output via print:\n")
+        c64scr.print(s1)
+        c64scr.print(s2)
+
+        c64scr.print("\nThe top two screen lines are set via screencodes.\n")
+        ubyte i
+        for i in 0 to len(s1)-1 {
+            @($0400+i) = s1[i]
+            @($0400+40+i) = s2[i]
+        }
+    }
+}
diff --git a/examples/testarrays.p8 b/examples/testarrays.p8
index d864c26fe..6bfad28e3 100644
--- a/examples/testarrays.p8
+++ b/examples/testarrays.p8
@@ -11,8 +11,9 @@ main {
         c64scr.print("this is only a parser/compiler test\n")
         return
 
-        str  s1 = "irmen"
-        str_s  s2 = "hello"
+        str  s1 = "hello"
+        str  s2 = "screencodes" ; TODO as c64sc
+
         &str  ms1 = $c000
 
 
@@ -37,7 +38,6 @@ main {
         ; read array
         A=s1[2]
         ub=s1[2]
-        ub=s2[2]
         bb=barray[2]
         ub=ubarray[2]
         ww=warray[2]
@@ -52,8 +52,7 @@ main {
         fl=mflarray[2]
 
         A=s1[A]
-        ub=s2[A]
-        ub=s2[A]
+        ub=s1[A]
         bb=barray[A]
         ub=ubarray[A]
         ww=warray[A]
@@ -69,7 +68,6 @@ main {
 
         A=s1[bb]
         ub=s1[bb]
-        ub=s2[bb]
         bb=barray[bb]
         ub=ubarray[bb]
         ww=warray[bb]
@@ -85,7 +83,6 @@ main {
 
         A=s1[bb*3]
         ub=s1[bb*3]
-        ub=s2[bb*3]
         bb=barray[bb*3]
         ub=ubarray[bb*3]
         ww=warray[bb*3]
@@ -104,7 +101,6 @@ main {
         barray[2]--
         s1[2] = A
         s1[2] = ub
-        s2[2] = ub
         barray[2] = bb
         ubarray[2] = ub
         warray[2] = ww
@@ -121,7 +117,6 @@ main {
         mflarray[2] = fl
 
         s1[A] = ub
-        s2[A] = ub
         barray[A] = bb
         ubarray[A] = ub
         warray[A] = ww
@@ -129,7 +124,6 @@ main {
         flarray[A] = fl
 
         s1[bb] = ub
-        s2[bb] = ub
         barray[bb] = bb
         ubarray[bb] = ub
         warray[bb] = ww
@@ -137,7 +131,6 @@ main {
         flarray[bb] = fl
 
         s1[bb*3] = ub
-        s2[bb*3] = ub
         barray[bb*3] = bb
         ubarray[bb*3] = ub
         warray[bb*3] = ww
diff --git a/parser/antlr/prog8.g4 b/parser/antlr/prog8.g4
index 2a07a4f34..94d14886c 100644
--- a/parser/antlr/prog8.g4
+++ b/parser/antlr/prog8.g4
@@ -126,7 +126,7 @@ memoryvardecl: ADDRESS_OF varinitializer;
 
 structdecl: 'struct' identifier '{' EOL vardecl ( EOL vardecl)* EOL? '}' EOL;
 
-datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_s' ;
+datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' ;
 
 arrayindex:  '[' expression ']' ;
 
diff --git a/parser/src/prog8/parser/prog8Lexer.java b/parser/src/prog8/parser/prog8Lexer.java
index 0169e5586..a349fdf53 100644
--- a/parser/src/prog8/parser/prog8Lexer.java
+++ b/parser/src/prog8/parser/prog8Lexer.java
@@ -34,10 +34,10 @@ public class prog8Lexer extends Lexer {
 		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
 		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
 		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
-		T__107=108, T__108=109, T__109=110, LINECOMMENT=111, COMMENT=112, WS=113, 
-		EOL=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, 
-		ADDRESS_OF=119, FLOAT_NUMBER=120, STRING=121, INLINEASMBLOCK=122, SINGLECHAR=123, 
-		ZEROPAGE=124, ARRAYSIG=125;
+		T__107=108, T__108=109, LINECOMMENT=110, COMMENT=111, WS=112, EOL=113, 
+		NAME=114, DEC_INTEGER=115, HEX_INTEGER=116, BIN_INTEGER=117, ADDRESS_OF=118, 
+		FLOAT_NUMBER=119, STRING=120, INLINEASMBLOCK=121, SINGLECHAR=122, ZEROPAGE=123, 
+		ARRAYSIG=124;
 	public static String[] channelNames = {
 		"DEFAULT_TOKEN_CHANNEL", "HIDDEN"
 	};
@@ -61,8 +61,8 @@ public class prog8Lexer extends Lexer {
 			"T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", 
 			"T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96", 
 			"T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104", 
-			"T__105", "T__106", "T__107", "T__108", "T__109", "LINECOMMENT", "COMMENT", 
-			"WS", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", 
+			"T__105", "T__106", "T__107", "T__108", "LINECOMMENT", "COMMENT", "WS", 
+			"EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", 
 			"FLOAT_NUMBER", "FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK", 
 			"SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
 		};
@@ -74,19 +74,19 @@ public class prog8Lexer extends Lexer {
 			null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'", 
 			"'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'", 
 			"'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'", 
-			"'byte'", "'uword'", "'word'", "'float'", "'str'", "'str_s'", "'['", 
-			"']'", "'+='", "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", 
-			"'%='", "'<<='", "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", 
-			"'*'", "'/'", "'%'", "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", 
-			"'!='", "'^'", "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", 
-			"'('", "')'", "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", 
-			"'A'", "'X'", "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", 
-			"'Pv'", "'.w'", "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", 
-			"'stack'", "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", 
-			"'if_z'", "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", 
-			"'if_vs'", "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", 
-			"'when'", null, null, null, null, null, null, null, null, "'&'", null, 
-			null, null, null, "'@zp'", "'[]'"
+			"'byte'", "'uword'", "'word'", "'float'", "'str'", "'['", "']'", "'+='", 
+			"'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='", 
+			"'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'*'", "'/'", "'%'", 
+			"'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'", 
+			"'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'", 
+			"'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'A'", "'X'", 
+			"'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'", 
+			"'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'stack'", 
+			"'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'", 
+			"'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'", 
+			"'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'when'", 
+			null, null, null, null, null, null, null, null, "'&'", null, null, null, 
+			null, "'@zp'", "'[]'"
 		};
 	}
 	private static final String[] _LITERAL_NAMES = makeLiteralNames();
@@ -101,7 +101,7 @@ public class prog8Lexer extends Lexer {
 			null, null, null, null, null, null, null, null, null, null, null, null, 
 			null, null, null, null, null, null, null, null, null, null, null, null, 
 			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", 
+			null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", 
 			"HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", 
 			"INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
 		};
@@ -167,13 +167,13 @@ public class prog8Lexer extends Lexer {
 	@Override
 	public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
 		switch (ruleIndex) {
-		case 122:
+		case 121:
 			STRING_action((RuleContext)_localctx, actionIndex);
 			break;
-		case 123:
+		case 122:
 			INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex);
 			break;
-		case 124:
+		case 123:
 			SINGLECHAR_action((RuleContext)_localctx, actionIndex);
 			break;
 		}
@@ -213,297 +213,294 @@ public class prog8Lexer extends Lexer {
 	}
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\177\u036e\b\1\4\2"+
-		"\t\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4"+
-		"\13\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22"+
-		"\t\22\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31"+
-		"\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+
-		" \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+
-		"+\4,\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64"+
-		"\t\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t"+
-		"=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4"+
-		"I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t"+
-		"T\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_"+
-		"\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k"+
-		"\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv"+
-		"\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t"+
-		"\u0080\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5"+
-		"\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+
-		"\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+
-		"\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3"+
-		"\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+
-		"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3"+
-		"\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20"+
-		"\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24"+
-		"\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26"+
-		"\3\26\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31"+
-		"\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35"+
-		"\3\35\3\36\3\36\3\36\3\37\3\37\3\37\3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3"+
-		"#\3#\3#\3$\3$\3$\3%\3%\3%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3(\3(\3(\3)\3)\3"+
-		")\3*\3*\3+\3+\3,\3,\3-\3-\3-\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\61\3\62"+
-		"\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67"+
-		"\3\67\38\38\38\39\39\3:\3:\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3>\3>\3"+
-		">\3?\3?\3?\3?\3@\3@\3@\3@\3A\3A\3B\3B\3C\3C\3C\3D\3D\3E\3E\3E\3E\3E\3"+
-		"E\3E\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3H\3H\3I\3I\3J\3J\3"+
-		"K\3K\3L\3L\3L\3M\3M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3"+
-		"S\3S\3S\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3W\3W\3W\3W\3"+
-		"X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3[\3[\3"+
-		"[\3[\3\\\3\\\3\\\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3"+
-		"`\3`\3`\3`\3`\3`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3"+
-		"d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3"+
-		"g\3g\3g\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3k\3k\3k\3l\3"+
-		"l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3o\3"+
-		"p\3p\7p\u02f4\np\fp\16p\u02f7\13p\3p\3p\3p\3p\3q\3q\7q\u02ff\nq\fq\16"+
-		"q\u0302\13q\3q\3q\3r\3r\3r\3r\3s\6s\u030b\ns\rs\16s\u030c\3t\3t\7t\u0311"+
-		"\nt\ft\16t\u0314\13t\3u\3u\3u\6u\u0319\nu\ru\16u\u031a\5u\u031d\nu\3v"+
-		"\3v\6v\u0321\nv\rv\16v\u0322\3w\3w\6w\u0327\nw\rw\16w\u0328\3x\3x\3y\3"+
-		"y\3y\5y\u0330\ny\3y\5y\u0333\ny\3z\6z\u0336\nz\rz\16z\u0337\3z\3z\6z\u033c"+
-		"\nz\rz\16z\u033d\5z\u0340\nz\3{\3{\3{\3{\5{\u0346\n{\3|\3|\3|\7|\u034b"+
-		"\n|\f|\16|\u034e\13|\3|\3|\3|\3}\3}\3}\3}\6}\u0357\n}\r}\16}\u0358\3}"+
-		"\3}\3}\3}\3}\3~\3~\3~\5~\u0363\n~\3~\3~\3~\3\177\3\177\3\177\3\177\3\u0080"+
-		"\3\u0080\3\u0080\3\u0358\2\u0081\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+
-		"\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+
-		"\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60"+
-		"_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085"+
-		"D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099"+
-		"N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00ad"+
-		"X\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1"+
-		"b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5"+
-		"l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9"+
-		"v\u00ebw\u00edx\u00efy\u00f1z\u00f3\2\u00f5\2\u00f7{\u00f9|\u00fb}\u00fd"+
-		"~\u00ff\177\3\2\n\4\2\f\f\17\17\4\2\13\13\"\"\5\2C\\aac|\6\2\62;C\\aa"+
-		"c|\5\2\62;CHch\4\2GGgg\4\2--//\6\2\f\f\16\17$$^^\2\u037d\2\3\3\2\2\2\2"+
-		"\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2"+
-		"\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2"+
-		"\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2"+
-		"\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2"+
-		"\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2"+
-		"\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2"+
-		"K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3"+
-		"\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2"+
-		"\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2"+
-		"q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3"+
-		"\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2"+
-		"\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f"+
-		"\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2"+
-		"\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1"+
-		"\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2"+
-		"\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3"+
-		"\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2"+
-		"\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5"+
-		"\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2"+
-		"\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7"+
-		"\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2"+
-		"\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9"+
-		"\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2"+
-		"\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff"+
-		"\3\2\2\2\3\u0101\3\2\2\2\5\u0103\3\2\2\2\7\u0108\3\2\2\2\t\u0110\3\2\2"+
-		"\2\13\u011a\3\2\2\2\r\u0124\3\2\2\2\17\u0130\3\2\2\2\21\u0139\3\2\2\2"+
-		"\23\u0141\3\2\2\2\25\u014d\3\2\2\2\27\u0159\3\2\2\2\31\u0164\3\2\2\2\33"+
-		"\u016c\3\2\2\2\35\u016e\3\2\2\2\37\u0170\3\2\2\2!\u0176\3\2\2\2#\u017d"+
-		"\3\2\2\2%\u017f\3\2\2\2\'\u0181\3\2\2\2)\u0187\3\2\2\2+\u018c\3\2\2\2"+
-		"-\u0192\3\2\2\2/\u0197\3\2\2\2\61\u019d\3\2\2\2\63\u01a1\3\2\2\2\65\u01a7"+
-		"\3\2\2\2\67\u01a9\3\2\2\29\u01ab\3\2\2\2;\u01ae\3\2\2\2=\u01b1\3\2\2\2"+
-		"?\u01b4\3\2\2\2A\u01b7\3\2\2\2C\u01bb\3\2\2\2E\u01be\3\2\2\2G\u01c1\3"+
-		"\2\2\2I\u01c4\3\2\2\2K\u01c7\3\2\2\2M\u01cb\3\2\2\2O\u01cf\3\2\2\2Q\u01d2"+
-		"\3\2\2\2S\u01d5\3\2\2\2U\u01d7\3\2\2\2W\u01d9\3\2\2\2Y\u01db\3\2\2\2["+
-		"\u01de\3\2\2\2]\u01e0\3\2\2\2_\u01e2\3\2\2\2a\u01e4\3\2\2\2c\u01e7\3\2"+
-		"\2\2e\u01ea\3\2\2\2g\u01ec\3\2\2\2i\u01ee\3\2\2\2k\u01f1\3\2\2\2m\u01f4"+
-		"\3\2\2\2o\u01f7\3\2\2\2q\u01fa\3\2\2\2s\u01fc\3\2\2\2u\u01fe\3\2\2\2w"+
-		"\u0201\3\2\2\2y\u0206\3\2\2\2{\u020a\3\2\2\2}\u020d\3\2\2\2\177\u0211"+
-		"\3\2\2\2\u0081\u0215\3\2\2\2\u0083\u0217\3\2\2\2\u0085\u0219\3\2\2\2\u0087"+
-		"\u021c\3\2\2\2\u0089\u021e\3\2\2\2\u008b\u0225\3\2\2\2\u008d\u022b\3\2"+
-		"\2\2\u008f\u0234\3\2\2\2\u0091\u0236\3\2\2\2\u0093\u0238\3\2\2\2\u0095"+
-		"\u023a\3\2\2\2\u0097\u023c\3\2\2\2\u0099\u023f\3\2\2\2\u009b\u0242\3\2"+
-		"\2\2\u009d\u0245\3\2\2\2\u009f\u0248\3\2\2\2\u00a1\u024b\3\2\2\2\u00a3"+
-		"\u024e\3\2\2\2\u00a5\u0251\3\2\2\2\u00a7\u0254\3\2\2\2\u00a9\u0259\3\2"+
-		"\2\2\u00ab\u025f\3\2\2\2\u00ad\u0264\3\2\2\2\u00af\u0268\3\2\2\2\u00b1"+
-		"\u026b\3\2\2\2\u00b3\u0272\3\2\2\2\u00b5\u0278\3\2\2\2\u00b7\u0281\3\2"+
-		"\2\2\u00b9\u0284\3\2\2\2\u00bb\u0289\3\2\2\2\u00bd\u028f\3\2\2\2\u00bf"+
-		"\u0295\3\2\2\2\u00c1\u029b\3\2\2\2\u00c3\u02a0\3\2\2\2\u00c5\u02a6\3\2"+
-		"\2\2\u00c7\u02ac\3\2\2\2\u00c9\u02b2\3\2\2\2\u00cb\u02b9\3\2\2\2\u00cd"+
-		"\u02bf\3\2\2\2\u00cf\u02c6\3\2\2\2\u00d1\u02cc\3\2\2\2\u00d3\u02d2\3\2"+
-		"\2\2\u00d5\u02d6\3\2\2\2\u00d7\u02d9\3\2\2\2\u00d9\u02df\3\2\2\2\u00db"+
-		"\u02e6\3\2\2\2\u00dd\u02ec\3\2\2\2\u00df\u02f1\3\2\2\2\u00e1\u02fc\3\2"+
-		"\2\2\u00e3\u0305\3\2\2\2\u00e5\u030a\3\2\2\2\u00e7\u030e\3\2\2\2\u00e9"+
-		"\u031c\3\2\2\2\u00eb\u031e\3\2\2\2\u00ed\u0324\3\2\2\2\u00ef\u032a\3\2"+
-		"\2\2\u00f1\u032c\3\2\2\2\u00f3\u0335\3\2\2\2\u00f5\u0345\3\2\2\2\u00f7"+
-		"\u0347\3\2\2\2\u00f9\u0352\3\2\2\2\u00fb\u035f\3\2\2\2\u00fd\u0367\3\2"+
-		"\2\2\u00ff\u036b\3\2\2\2\u0101\u0102\7<\2\2\u0102\4\3\2\2\2\u0103\u0104"+
-		"\7i\2\2\u0104\u0105\7q\2\2\u0105\u0106\7v\2\2\u0106\u0107\7q\2\2\u0107"+
-		"\6\3\2\2\2\u0108\u0109\7\'\2\2\u0109\u010a\7q\2\2\u010a\u010b\7w\2\2\u010b"+
-		"\u010c\7v\2\2\u010c\u010d\7r\2\2\u010d\u010e\7w\2\2\u010e\u010f\7v\2\2"+
-		"\u010f\b\3\2\2\2\u0110\u0111\7\'\2\2\u0111\u0112\7n\2\2\u0112\u0113\7"+
-		"c\2\2\u0113\u0114\7w\2\2\u0114\u0115\7p\2\2\u0115\u0116\7e\2\2\u0116\u0117"+
-		"\7j\2\2\u0117\u0118\7g\2\2\u0118\u0119\7t\2\2\u0119\n\3\2\2\2\u011a\u011b"+
-		"\7\'\2\2\u011b\u011c\7|\2\2\u011c\u011d\7g\2\2\u011d\u011e\7t\2\2\u011e"+
-		"\u011f\7q\2\2\u011f\u0120\7r\2\2\u0120\u0121\7c\2\2\u0121\u0122\7i\2\2"+
-		"\u0122\u0123\7g\2\2\u0123\f\3\2\2\2\u0124\u0125\7\'\2\2\u0125\u0126\7"+
-		"|\2\2\u0126\u0127\7r\2\2\u0127\u0128\7t\2\2\u0128\u0129\7g\2\2\u0129\u012a"+
-		"\7u\2\2\u012a\u012b\7g\2\2\u012b\u012c\7t\2\2\u012c\u012d\7x\2\2\u012d"+
-		"\u012e\7g\2\2\u012e\u012f\7f\2\2\u012f\16\3\2\2\2\u0130\u0131\7\'\2\2"+
-		"\u0131\u0132\7c\2\2\u0132\u0133\7f\2\2\u0133\u0134\7f\2\2\u0134\u0135"+
-		"\7t\2\2\u0135\u0136\7g\2\2\u0136\u0137\7u\2\2\u0137\u0138\7u\2\2\u0138"+
-		"\20\3\2\2\2\u0139\u013a\7\'\2\2\u013a\u013b\7k\2\2\u013b\u013c\7o\2\2"+
-		"\u013c\u013d\7r\2\2\u013d\u013e\7q\2\2\u013e\u013f\7t\2\2\u013f\u0140"+
-		"\7v\2\2\u0140\22\3\2\2\2\u0141\u0142\7\'\2\2\u0142\u0143\7d\2\2\u0143"+
-		"\u0144\7t\2\2\u0144\u0145\7g\2\2\u0145\u0146\7c\2\2\u0146\u0147\7m\2\2"+
-		"\u0147\u0148\7r\2\2\u0148\u0149\7q\2\2\u0149\u014a\7k\2\2\u014a\u014b"+
-		"\7p\2\2\u014b\u014c\7v\2\2\u014c\24\3\2\2\2\u014d\u014e\7\'\2\2\u014e"+
-		"\u014f\7c\2\2\u014f\u0150\7u\2\2\u0150\u0151\7o\2\2\u0151\u0152\7k\2\2"+
-		"\u0152\u0153\7p\2\2\u0153\u0154\7e\2\2\u0154\u0155\7n\2\2\u0155\u0156"+
-		"\7w\2\2\u0156\u0157\7f\2\2\u0157\u0158\7g\2\2\u0158\26\3\2\2\2\u0159\u015a"+
-		"\7\'\2\2\u015a\u015b\7c\2\2\u015b\u015c\7u\2\2\u015c\u015d\7o\2\2\u015d"+
-		"\u015e\7d\2\2\u015e\u015f\7k\2\2\u015f\u0160\7p\2\2\u0160\u0161\7c\2\2"+
-		"\u0161\u0162\7t\2\2\u0162\u0163\7{\2\2\u0163\30\3\2\2\2\u0164\u0165\7"+
-		"\'\2\2\u0165\u0166\7q\2\2\u0166\u0167\7r\2\2\u0167\u0168\7v\2\2\u0168"+
-		"\u0169\7k\2\2\u0169\u016a\7q\2\2\u016a\u016b\7p\2\2\u016b\32\3\2\2\2\u016c"+
-		"\u016d\7.\2\2\u016d\34\3\2\2\2\u016e\u016f\7?\2\2\u016f\36\3\2\2\2\u0170"+
-		"\u0171\7e\2\2\u0171\u0172\7q\2\2\u0172\u0173\7p\2\2\u0173\u0174\7u\2\2"+
-		"\u0174\u0175\7v\2\2\u0175 \3\2\2\2\u0176\u0177\7u\2\2\u0177\u0178\7v\2"+
-		"\2\u0178\u0179\7t\2\2\u0179\u017a\7w\2\2\u017a\u017b\7e\2\2\u017b\u017c"+
-		"\7v\2\2\u017c\"\3\2\2\2\u017d\u017e\7}\2\2\u017e$\3\2\2\2\u017f\u0180"+
-		"\7\177\2\2\u0180&\3\2\2\2\u0181\u0182\7w\2\2\u0182\u0183\7d\2\2\u0183"+
-		"\u0184\7{\2\2\u0184\u0185\7v\2\2\u0185\u0186\7g\2\2\u0186(\3\2\2\2\u0187"+
-		"\u0188\7d\2\2\u0188\u0189\7{\2\2\u0189\u018a\7v\2\2\u018a\u018b\7g\2\2"+
-		"\u018b*\3\2\2\2\u018c\u018d\7w\2\2\u018d\u018e\7y\2\2\u018e\u018f\7q\2"+
-		"\2\u018f\u0190\7t\2\2\u0190\u0191\7f\2\2\u0191,\3\2\2\2\u0192\u0193\7"+
-		"y\2\2\u0193\u0194\7q\2\2\u0194\u0195\7t\2\2\u0195\u0196\7f\2\2\u0196."+
-		"\3\2\2\2\u0197\u0198\7h\2\2\u0198\u0199\7n\2\2\u0199\u019a\7q\2\2\u019a"+
-		"\u019b\7c\2\2\u019b\u019c\7v\2\2\u019c\60\3\2\2\2\u019d\u019e\7u\2\2\u019e"+
-		"\u019f\7v\2\2\u019f\u01a0\7t\2\2\u01a0\62\3\2\2\2\u01a1\u01a2\7u\2\2\u01a2"+
-		"\u01a3\7v\2\2\u01a3\u01a4\7t\2\2\u01a4\u01a5\7a\2\2\u01a5\u01a6\7u\2\2"+
-		"\u01a6\64\3\2\2\2\u01a7\u01a8\7]\2\2\u01a8\66\3\2\2\2\u01a9\u01aa\7_\2"+
-		"\2\u01aa8\3\2\2\2\u01ab\u01ac\7-\2\2\u01ac\u01ad\7?\2\2\u01ad:\3\2\2\2"+
-		"\u01ae\u01af\7/\2\2\u01af\u01b0\7?\2\2\u01b0<\3\2\2\2\u01b1\u01b2\7\61"+
-		"\2\2\u01b2\u01b3\7?\2\2\u01b3>\3\2\2\2\u01b4\u01b5\7,\2\2\u01b5\u01b6"+
-		"\7?\2\2\u01b6@\3\2\2\2\u01b7\u01b8\7,\2\2\u01b8\u01b9\7,\2\2\u01b9\u01ba"+
-		"\7?\2\2\u01baB\3\2\2\2\u01bb\u01bc\7(\2\2\u01bc\u01bd\7?\2\2\u01bdD\3"+
-		"\2\2\2\u01be\u01bf\7~\2\2\u01bf\u01c0\7?\2\2\u01c0F\3\2\2\2\u01c1\u01c2"+
-		"\7`\2\2\u01c2\u01c3\7?\2\2\u01c3H\3\2\2\2\u01c4\u01c5\7\'\2\2\u01c5\u01c6"+
-		"\7?\2\2\u01c6J\3\2\2\2\u01c7\u01c8\7>\2\2\u01c8\u01c9\7>\2\2\u01c9\u01ca"+
-		"\7?\2\2\u01caL\3\2\2\2\u01cb\u01cc\7@\2\2\u01cc\u01cd\7@\2\2\u01cd\u01ce"+
-		"\7?\2\2\u01ceN\3\2\2\2\u01cf\u01d0\7-\2\2\u01d0\u01d1\7-\2\2\u01d1P\3"+
-		"\2\2\2\u01d2\u01d3\7/\2\2\u01d3\u01d4\7/\2\2\u01d4R\3\2\2\2\u01d5\u01d6"+
-		"\7-\2\2\u01d6T\3\2\2\2\u01d7\u01d8\7/\2\2\u01d8V\3\2\2\2\u01d9\u01da\7"+
-		"\u0080\2\2\u01daX\3\2\2\2\u01db\u01dc\7,\2\2\u01dc\u01dd\7,\2\2\u01dd"+
-		"Z\3\2\2\2\u01de\u01df\7,\2\2\u01df\\\3\2\2\2\u01e0\u01e1\7\61\2\2\u01e1"+
-		"^\3\2\2\2\u01e2\u01e3\7\'\2\2\u01e3`\3\2\2\2\u01e4\u01e5\7>\2\2\u01e5"+
-		"\u01e6\7>\2\2\u01e6b\3\2\2\2\u01e7\u01e8\7@\2\2\u01e8\u01e9\7@\2\2\u01e9"+
-		"d\3\2\2\2\u01ea\u01eb\7>\2\2\u01ebf\3\2\2\2\u01ec\u01ed\7@\2\2\u01edh"+
-		"\3\2\2\2\u01ee\u01ef\7>\2\2\u01ef\u01f0\7?\2\2\u01f0j\3\2\2\2\u01f1\u01f2"+
-		"\7@\2\2\u01f2\u01f3\7?\2\2\u01f3l\3\2\2\2\u01f4\u01f5\7?\2\2\u01f5\u01f6"+
-		"\7?\2\2\u01f6n\3\2\2\2\u01f7\u01f8\7#\2\2\u01f8\u01f9\7?\2\2\u01f9p\3"+
-		"\2\2\2\u01fa\u01fb\7`\2\2\u01fbr\3\2\2\2\u01fc\u01fd\7~\2\2\u01fdt\3\2"+
-		"\2\2\u01fe\u01ff\7v\2\2\u01ff\u0200\7q\2\2\u0200v\3\2\2\2\u0201\u0202"+
-		"\7u\2\2\u0202\u0203\7v\2\2\u0203\u0204\7g\2\2\u0204\u0205\7r\2\2\u0205"+
-		"x\3\2\2\2\u0206\u0207\7c\2\2\u0207\u0208\7p\2\2\u0208\u0209\7f\2\2\u0209"+
-		"z\3\2\2\2\u020a\u020b\7q\2\2\u020b\u020c\7t\2\2\u020c|\3\2\2\2\u020d\u020e"+
-		"\7z\2\2\u020e\u020f\7q\2\2\u020f\u0210\7t\2\2\u0210~\3\2\2\2\u0211\u0212"+
-		"\7p\2\2\u0212\u0213\7q\2\2\u0213\u0214\7v\2\2\u0214\u0080\3\2\2\2\u0215"+
-		"\u0216\7*\2\2\u0216\u0082\3\2\2\2\u0217\u0218\7+\2\2\u0218\u0084\3\2\2"+
-		"\2\u0219\u021a\7c\2\2\u021a\u021b\7u\2\2\u021b\u0086\3\2\2\2\u021c\u021d"+
-		"\7B\2\2\u021d\u0088\3\2\2\2\u021e\u021f\7t\2\2\u021f\u0220\7g\2\2\u0220"+
-		"\u0221\7v\2\2\u0221\u0222\7w\2\2\u0222\u0223\7t\2\2\u0223\u0224\7p\2\2"+
-		"\u0224\u008a\3\2\2\2\u0225\u0226\7d\2\2\u0226\u0227\7t\2\2\u0227\u0228"+
-		"\7g\2\2\u0228\u0229\7c\2\2\u0229\u022a\7m\2\2\u022a\u008c\3\2\2\2\u022b"+
-		"\u022c\7e\2\2\u022c\u022d\7q\2\2\u022d\u022e\7p\2\2\u022e\u022f\7v\2\2"+
-		"\u022f\u0230\7k\2\2\u0230\u0231\7p\2\2\u0231\u0232\7w\2\2\u0232\u0233"+
-		"\7g\2\2\u0233\u008e\3\2\2\2\u0234\u0235\7\60\2\2\u0235\u0090\3\2\2\2\u0236"+
-		"\u0237\7C\2\2\u0237\u0092\3\2\2\2\u0238\u0239\7Z\2\2\u0239\u0094\3\2\2"+
-		"\2\u023a\u023b\7[\2\2\u023b\u0096\3\2\2\2\u023c\u023d\7C\2\2\u023d\u023e"+
-		"\7Z\2\2\u023e\u0098\3\2\2\2\u023f\u0240\7C\2\2\u0240\u0241\7[\2\2\u0241"+
-		"\u009a\3\2\2\2\u0242\u0243\7Z\2\2\u0243\u0244\7[\2\2\u0244\u009c\3\2\2"+
-		"\2\u0245\u0246\7R\2\2\u0246\u0247\7e\2\2\u0247\u009e\3\2\2\2\u0248\u0249"+
-		"\7R\2\2\u0249\u024a\7|\2\2\u024a\u00a0\3\2\2\2\u024b\u024c\7R\2\2\u024c"+
-		"\u024d\7p\2\2\u024d\u00a2\3\2\2\2\u024e\u024f\7R\2\2\u024f\u0250\7x\2"+
-		"\2\u0250\u00a4\3\2\2\2\u0251\u0252\7\60\2\2\u0252\u0253\7y\2\2\u0253\u00a6"+
-		"\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7t\2\2\u0256\u0257\7w\2\2\u0257"+
-		"\u0258\7g\2\2\u0258\u00a8\3\2\2\2\u0259\u025a\7h\2\2\u025a\u025b\7c\2"+
-		"\2\u025b\u025c\7n\2\2\u025c\u025d\7u\2\2\u025d\u025e\7g\2\2\u025e\u00aa"+
-		"\3\2\2\2\u025f\u0260\7\'\2\2\u0260\u0261\7c\2\2\u0261\u0262\7u\2\2\u0262"+
-		"\u0263\7o\2\2\u0263\u00ac\3\2\2\2\u0264\u0265\7u\2\2\u0265\u0266\7w\2"+
-		"\2\u0266\u0267\7d\2\2\u0267\u00ae\3\2\2\2\u0268\u0269\7/\2\2\u0269\u026a"+
-		"\7@\2\2\u026a\u00b0\3\2\2\2\u026b\u026c\7c\2\2\u026c\u026d\7u\2\2\u026d"+
-		"\u026e\7o\2\2\u026e\u026f\7u\2\2\u026f\u0270\7w\2\2\u0270\u0271\7d\2\2"+
-		"\u0271\u00b2\3\2\2\2\u0272\u0273\7u\2\2\u0273\u0274\7v\2\2\u0274\u0275"+
-		"\7c\2\2\u0275\u0276\7e\2\2\u0276\u0277\7m\2\2\u0277\u00b4\3\2\2\2\u0278"+
-		"\u0279\7e\2\2\u0279\u027a\7n\2\2\u027a\u027b\7q\2\2\u027b\u027c\7d\2\2"+
-		"\u027c\u027d\7d\2\2\u027d\u027e\7g\2\2\u027e\u027f\7t\2\2\u027f\u0280"+
-		"\7u\2\2\u0280\u00b6\3\2\2\2\u0281\u0282\7k\2\2\u0282\u0283\7h\2\2\u0283"+
-		"\u00b8\3\2\2\2\u0284\u0285\7g\2\2\u0285\u0286\7n\2\2\u0286\u0287\7u\2"+
-		"\2\u0287\u0288\7g\2\2\u0288\u00ba\3\2\2\2\u0289\u028a\7k\2\2\u028a\u028b"+
-		"\7h\2\2\u028b\u028c\7a\2\2\u028c\u028d\7e\2\2\u028d\u028e\7u\2\2\u028e"+
-		"\u00bc\3\2\2\2\u028f\u0290\7k\2\2\u0290\u0291\7h\2\2\u0291\u0292\7a\2"+
-		"\2\u0292\u0293\7e\2\2\u0293\u0294\7e\2\2\u0294\u00be\3\2\2\2\u0295\u0296"+
-		"\7k\2\2\u0296\u0297\7h\2\2\u0297\u0298\7a\2\2\u0298\u0299\7g\2\2\u0299"+
-		"\u029a\7s\2\2\u029a\u00c0\3\2\2\2\u029b\u029c\7k\2\2\u029c\u029d\7h\2"+
-		"\2\u029d\u029e\7a\2\2\u029e\u029f\7|\2\2\u029f\u00c2\3\2\2\2\u02a0\u02a1"+
-		"\7k\2\2\u02a1\u02a2\7h\2\2\u02a2\u02a3\7a\2\2\u02a3\u02a4\7p\2\2\u02a4"+
-		"\u02a5\7g\2\2\u02a5\u00c4\3\2\2\2\u02a6\u02a7\7k\2\2\u02a7\u02a8\7h\2"+
-		"\2\u02a8\u02a9\7a\2\2\u02a9\u02aa\7p\2\2\u02aa\u02ab\7|\2\2\u02ab\u00c6"+
-		"\3\2\2\2\u02ac\u02ad\7k\2\2\u02ad\u02ae\7h\2\2\u02ae\u02af\7a\2\2\u02af"+
-		"\u02b0\7r\2\2\u02b0\u02b1\7n\2\2\u02b1\u00c8\3\2\2\2\u02b2\u02b3\7k\2"+
-		"\2\u02b3\u02b4\7h\2\2\u02b4\u02b5\7a\2\2\u02b5\u02b6\7r\2\2\u02b6\u02b7"+
-		"\7q\2\2\u02b7\u02b8\7u\2\2\u02b8\u00ca\3\2\2\2\u02b9\u02ba\7k\2\2\u02ba"+
-		"\u02bb\7h\2\2\u02bb\u02bc\7a\2\2\u02bc\u02bd\7o\2\2\u02bd\u02be\7k\2\2"+
-		"\u02be\u00cc\3\2\2\2\u02bf\u02c0\7k\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2"+
-		"\7a\2\2\u02c2\u02c3\7p\2\2\u02c3\u02c4\7g\2\2\u02c4\u02c5\7i\2\2\u02c5"+
-		"\u00ce\3\2\2\2\u02c6\u02c7\7k\2\2\u02c7\u02c8\7h\2\2\u02c8\u02c9\7a\2"+
-		"\2\u02c9\u02ca\7x\2\2\u02ca\u02cb\7u\2\2\u02cb\u00d0\3\2\2\2\u02cc\u02cd"+
-		"\7k\2\2\u02cd\u02ce\7h\2\2\u02ce\u02cf\7a\2\2\u02cf\u02d0\7x\2\2\u02d0"+
-		"\u02d1\7e\2\2\u02d1\u00d2\3\2\2\2\u02d2\u02d3\7h\2\2\u02d3\u02d4\7q\2"+
-		"\2\u02d4\u02d5\7t\2\2\u02d5\u00d4\3\2\2\2\u02d6\u02d7\7k\2\2\u02d7\u02d8"+
-		"\7p\2\2\u02d8\u00d6\3\2\2\2\u02d9\u02da\7y\2\2\u02da\u02db\7j\2\2\u02db"+
-		"\u02dc\7k\2\2\u02dc\u02dd\7n\2\2\u02dd\u02de\7g\2\2\u02de\u00d8\3\2\2"+
-		"\2\u02df\u02e0\7t\2\2\u02e0\u02e1\7g\2\2\u02e1\u02e2\7r\2\2\u02e2\u02e3"+
-		"\7g\2\2\u02e3\u02e4\7c\2\2\u02e4\u02e5\7v\2\2\u02e5\u00da\3\2\2\2\u02e6"+
-		"\u02e7\7w\2\2\u02e7\u02e8\7p\2\2\u02e8\u02e9\7v\2\2\u02e9\u02ea\7k\2\2"+
-		"\u02ea\u02eb\7n\2\2\u02eb\u00dc\3\2\2\2\u02ec\u02ed\7y\2\2\u02ed\u02ee"+
-		"\7j\2\2\u02ee\u02ef\7g\2\2\u02ef\u02f0\7p\2\2\u02f0\u00de\3\2\2\2\u02f1"+
-		"\u02f5\t\2\2\2\u02f2\u02f4\t\3\2\2\u02f3\u02f2\3\2\2\2\u02f4\u02f7\3\2"+
-		"\2\2\u02f5\u02f3\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02f8\3\2\2\2\u02f7"+
-		"\u02f5\3\2\2\2\u02f8\u02f9\5\u00e1q\2\u02f9\u02fa\3\2\2\2\u02fa\u02fb"+
-		"\bp\2\2\u02fb\u00e0\3\2\2\2\u02fc\u0300\7=\2\2\u02fd\u02ff\n\2\2\2\u02fe"+
-		"\u02fd\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2"+
-		"\2\2\u0301\u0303\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u0304\bq\2\2\u0304"+
-		"\u00e2\3\2\2\2\u0305\u0306\t\3\2\2\u0306\u0307\3\2\2\2\u0307\u0308\br"+
-		"\3\2\u0308\u00e4\3\2\2\2\u0309\u030b\t\2\2\2\u030a\u0309\3\2\2\2\u030b"+
-		"\u030c\3\2\2\2\u030c\u030a\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u00e6\3\2"+
-		"\2\2\u030e\u0312\t\4\2\2\u030f\u0311\t\5\2\2\u0310\u030f\3\2\2\2\u0311"+
-		"\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u00e8\3\2"+
-		"\2\2\u0314\u0312\3\2\2\2\u0315\u031d\4\62;\2\u0316\u0318\4\63;\2\u0317"+
-		"\u0319\4\62;\2\u0318\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u0318\3\2"+
-		"\2\2\u031a\u031b\3\2\2\2\u031b\u031d\3\2\2\2\u031c\u0315\3\2\2\2\u031c"+
-		"\u0316\3\2\2\2\u031d\u00ea\3\2\2\2\u031e\u0320\7&\2\2\u031f\u0321\t\6"+
-		"\2\2\u0320\u031f\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u0320\3\2\2\2\u0322"+
-		"\u0323\3\2\2\2\u0323\u00ec\3\2\2\2\u0324\u0326\7\'\2\2\u0325\u0327\4\62"+
-		"\63\2\u0326\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0326\3\2\2\2\u0328"+
-		"\u0329\3\2\2\2\u0329\u00ee\3\2\2\2\u032a\u032b\7(\2\2\u032b\u00f0\3\2"+
-		"\2\2\u032c\u0332\5\u00f3z\2\u032d\u032f\t\7\2\2\u032e\u0330\t\b\2\2\u032f"+
-		"\u032e\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\3\2\2\2\u0331\u0333\5\u00f3"+
-		"z\2\u0332\u032d\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u00f2\3\2\2\2\u0334"+
-		"\u0336\4\62;\2\u0335\u0334\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u0335\3\2"+
-		"\2\2\u0337\u0338\3\2\2\2\u0338\u033f\3\2\2\2\u0339\u033b\7\60\2\2\u033a"+
-		"\u033c\4\62;\2\u033b\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033b\3\2"+
-		"\2\2\u033d\u033e\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u0339\3\2\2\2\u033f"+
-		"\u0340\3\2\2\2\u0340\u00f4\3\2\2\2\u0341\u0342\7^\2\2\u0342\u0346\13\2"+
-		"\2\2\u0343\u0344\7^\2\2\u0344\u0346\5\u00e5s\2\u0345\u0341\3\2\2\2\u0345"+
-		"\u0343\3\2\2\2\u0346\u00f6\3\2\2\2\u0347\u034c\7$\2\2\u0348\u034b\5\u00f5"+
-		"{\2\u0349\u034b\n\t\2\2\u034a\u0348\3\2\2\2\u034a\u0349\3\2\2\2\u034b"+
-		"\u034e\3\2\2\2\u034c\u034a\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u034f\3\2"+
-		"\2\2\u034e\u034c\3\2\2\2\u034f\u0350\7$\2\2\u0350\u0351\b|\4\2\u0351\u00f8"+
-		"\3\2\2\2\u0352\u0353\7}\2\2\u0353\u0354\7}\2\2\u0354\u0356\3\2\2\2\u0355"+
-		"\u0357\13\2\2\2\u0356\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0359\3"+
-		"\2\2\2\u0358\u0356\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u035b\7\177\2\2\u035b"+
-		"\u035c\7\177\2\2\u035c\u035d\3\2\2\2\u035d\u035e\b}\5\2\u035e\u00fa\3"+
-		"\2\2\2\u035f\u0362\7)\2\2\u0360\u0363\5\u00f5{\2\u0361\u0363\n\t\2\2\u0362"+
-		"\u0360\3\2\2\2\u0362\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\7)"+
-		"\2\2\u0365\u0366\b~\6\2\u0366\u00fc\3\2\2\2\u0367\u0368\7B\2\2\u0368\u0369"+
-		"\7|\2\2\u0369\u036a\7r\2\2\u036a\u00fe\3\2\2\2\u036b\u036c\7]\2\2\u036c"+
-		"\u036d\7_\2\2\u036d\u0100\3\2\2\2\26\2\u02f5\u0300\u030c\u0312\u031a\u031c"+
-		"\u0320\u0322\u0328\u032f\u0332\u0337\u033d\u033f\u0345\u034a\u034c\u0358"+
-		"\u0362\7\2\3\2\b\2\2\3|\2\3}\3\3~\4";
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2~\u0366\b\1\4\2\t"+
+		"\2\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
+		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
+		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
+		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
+		",\t,\4-\t-\4.\t.\4/\t/\4\60\t\60\4\61\t\61\4\62\t\62\4\63\t\63\4\64\t"+
+		"\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
+		"\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
+		"\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
+		"\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
+		"`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
+		"k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
+		"w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\3\2\3\2\3\3"+
+		"\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3"+
+		"\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7"+
+		"\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
+		"\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+
+		"\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"+
+		"\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3"+
+		"\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21"+
+		"\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\24\3\24\3\24"+
+		"\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27"+
+		"\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32"+
+		"\3\32\3\33\3\33\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3\37"+
+		"\3\37\3 \3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3%\3%\3%\3%\3"+
+		"&\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3)\3)\3*\3*\3+\3+\3,\3,\3,\3-\3-\3.\3"+
+		".\3/\3/\3\60\3\60\3\60\3\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3"+
+		"\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3\67\38\38\39\39\3:\3:\3:"+
+		"\3;\3;\3;\3;\3;\3<\3<\3<\3<\3=\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\3@\3@\3A"+
+		"\3A\3B\3B\3B\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F"+
+		"\3F\3F\3F\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3K\3L\3L\3L\3M\3M\3M\3N"+
+		"\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S\3S\3T\3T\3T\3T"+
+		"\3T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3W\3W\3W\3X\3X\3X\3X\3X\3X\3X\3Y\3Y"+
+		"\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3"+
+		"]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3"+
+		"a\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3"+
+		"d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3"+
+		"h\3h\3h\3h\3i\3i\3i\3i\3j\3j\3j\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3"+
+		"l\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3o\3o\7o\u02ec\no\fo\16o\u02ef\13o"+
+		"\3o\3o\3o\3o\3p\3p\7p\u02f7\np\fp\16p\u02fa\13p\3p\3p\3q\3q\3q\3q\3r\6"+
+		"r\u0303\nr\rr\16r\u0304\3s\3s\7s\u0309\ns\fs\16s\u030c\13s\3t\3t\3t\6"+
+		"t\u0311\nt\rt\16t\u0312\5t\u0315\nt\3u\3u\6u\u0319\nu\ru\16u\u031a\3v"+
+		"\3v\6v\u031f\nv\rv\16v\u0320\3w\3w\3x\3x\3x\5x\u0328\nx\3x\5x\u032b\n"+
+		"x\3y\6y\u032e\ny\ry\16y\u032f\3y\3y\6y\u0334\ny\ry\16y\u0335\5y\u0338"+
+		"\ny\3z\3z\3z\3z\5z\u033e\nz\3{\3{\3{\7{\u0343\n{\f{\16{\u0346\13{\3{\3"+
+		"{\3{\3|\3|\3|\3|\6|\u034f\n|\r|\16|\u0350\3|\3|\3|\3|\3|\3}\3}\3}\5}\u035b"+
+		"\n}\3}\3}\3}\3~\3~\3~\3~\3\177\3\177\3\177\3\u0350\2\u0080\3\3\5\4\7\5"+
+		"\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+
+		"%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+
+		"%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{"+
+		"?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091"+
+		"J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5"+
+		"T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9"+
+		"^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cd"+
+		"h\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1"+
+		"r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1\2\u00f3\2\u00f5"+
+		"z\u00f7{\u00f9|\u00fb}\u00fd~\3\2\n\4\2\f\f\17\17\4\2\13\13\"\"\5\2C\\"+
+		"aac|\6\2\62;C\\aac|\5\2\62;CHch\4\2GGgg\4\2--//\6\2\f\f\16\17$$^^\2\u0375"+
+		"\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2"+
+		"\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2"+
+		"\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2"+
+		"\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2"+
+		"\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3"+
+		"\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2"+
+		"\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2"+
+		"U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3"+
+		"\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2"+
+		"\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2"+
+		"{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085"+
+		"\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2"+
+		"\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097"+
+		"\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2"+
+		"\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9"+
+		"\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2"+
+		"\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb"+
+		"\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2"+
+		"\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd"+
+		"\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2"+
+		"\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df"+
+		"\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2"+
+		"\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f5"+
+		"\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2"+
+		"\2\3\u00ff\3\2\2\2\5\u0101\3\2\2\2\7\u0106\3\2\2\2\t\u010e\3\2\2\2\13"+
+		"\u0118\3\2\2\2\r\u0122\3\2\2\2\17\u012e\3\2\2\2\21\u0137\3\2\2\2\23\u013f"+
+		"\3\2\2\2\25\u014b\3\2\2\2\27\u0157\3\2\2\2\31\u0162\3\2\2\2\33\u016a\3"+
+		"\2\2\2\35\u016c\3\2\2\2\37\u016e\3\2\2\2!\u0174\3\2\2\2#\u017b\3\2\2\2"+
+		"%\u017d\3\2\2\2\'\u017f\3\2\2\2)\u0185\3\2\2\2+\u018a\3\2\2\2-\u0190\3"+
+		"\2\2\2/\u0195\3\2\2\2\61\u019b\3\2\2\2\63\u019f\3\2\2\2\65\u01a1\3\2\2"+
+		"\2\67\u01a3\3\2\2\29\u01a6\3\2\2\2;\u01a9\3\2\2\2=\u01ac\3\2\2\2?\u01af"+
+		"\3\2\2\2A\u01b3\3\2\2\2C\u01b6\3\2\2\2E\u01b9\3\2\2\2G\u01bc\3\2\2\2I"+
+		"\u01bf\3\2\2\2K\u01c3\3\2\2\2M\u01c7\3\2\2\2O\u01ca\3\2\2\2Q\u01cd\3\2"+
+		"\2\2S\u01cf\3\2\2\2U\u01d1\3\2\2\2W\u01d3\3\2\2\2Y\u01d6\3\2\2\2[\u01d8"+
+		"\3\2\2\2]\u01da\3\2\2\2_\u01dc\3\2\2\2a\u01df\3\2\2\2c\u01e2\3\2\2\2e"+
+		"\u01e4\3\2\2\2g\u01e6\3\2\2\2i\u01e9\3\2\2\2k\u01ec\3\2\2\2m\u01ef\3\2"+
+		"\2\2o\u01f2\3\2\2\2q\u01f4\3\2\2\2s\u01f6\3\2\2\2u\u01f9\3\2\2\2w\u01fe"+
+		"\3\2\2\2y\u0202\3\2\2\2{\u0205\3\2\2\2}\u0209\3\2\2\2\177\u020d\3\2\2"+
+		"\2\u0081\u020f\3\2\2\2\u0083\u0211\3\2\2\2\u0085\u0214\3\2\2\2\u0087\u0216"+
+		"\3\2\2\2\u0089\u021d\3\2\2\2\u008b\u0223\3\2\2\2\u008d\u022c\3\2\2\2\u008f"+
+		"\u022e\3\2\2\2\u0091\u0230\3\2\2\2\u0093\u0232\3\2\2\2\u0095\u0234\3\2"+
+		"\2\2\u0097\u0237\3\2\2\2\u0099\u023a\3\2\2\2\u009b\u023d\3\2\2\2\u009d"+
+		"\u0240\3\2\2\2\u009f\u0243\3\2\2\2\u00a1\u0246\3\2\2\2\u00a3\u0249\3\2"+
+		"\2\2\u00a5\u024c\3\2\2\2\u00a7\u0251\3\2\2\2\u00a9\u0257\3\2\2\2\u00ab"+
+		"\u025c\3\2\2\2\u00ad\u0260\3\2\2\2\u00af\u0263\3\2\2\2\u00b1\u026a\3\2"+
+		"\2\2\u00b3\u0270\3\2\2\2\u00b5\u0279\3\2\2\2\u00b7\u027c\3\2\2\2\u00b9"+
+		"\u0281\3\2\2\2\u00bb\u0287\3\2\2\2\u00bd\u028d\3\2\2\2\u00bf\u0293\3\2"+
+		"\2\2\u00c1\u0298\3\2\2\2\u00c3\u029e\3\2\2\2\u00c5\u02a4\3\2\2\2\u00c7"+
+		"\u02aa\3\2\2\2\u00c9\u02b1\3\2\2\2\u00cb\u02b7\3\2\2\2\u00cd\u02be\3\2"+
+		"\2\2\u00cf\u02c4\3\2\2\2\u00d1\u02ca\3\2\2\2\u00d3\u02ce\3\2\2\2\u00d5"+
+		"\u02d1\3\2\2\2\u00d7\u02d7\3\2\2\2\u00d9\u02de\3\2\2\2\u00db\u02e4\3\2"+
+		"\2\2\u00dd\u02e9\3\2\2\2\u00df\u02f4\3\2\2\2\u00e1\u02fd\3\2\2\2\u00e3"+
+		"\u0302\3\2\2\2\u00e5\u0306\3\2\2\2\u00e7\u0314\3\2\2\2\u00e9\u0316\3\2"+
+		"\2\2\u00eb\u031c\3\2\2\2\u00ed\u0322\3\2\2\2\u00ef\u0324\3\2\2\2\u00f1"+
+		"\u032d\3\2\2\2\u00f3\u033d\3\2\2\2\u00f5\u033f\3\2\2\2\u00f7\u034a\3\2"+
+		"\2\2\u00f9\u0357\3\2\2\2\u00fb\u035f\3\2\2\2\u00fd\u0363\3\2\2\2\u00ff"+
+		"\u0100\7<\2\2\u0100\4\3\2\2\2\u0101\u0102\7i\2\2\u0102\u0103\7q\2\2\u0103"+
+		"\u0104\7v\2\2\u0104\u0105\7q\2\2\u0105\6\3\2\2\2\u0106\u0107\7\'\2\2\u0107"+
+		"\u0108\7q\2\2\u0108\u0109\7w\2\2\u0109\u010a\7v\2\2\u010a\u010b\7r\2\2"+
+		"\u010b\u010c\7w\2\2\u010c\u010d\7v\2\2\u010d\b\3\2\2\2\u010e\u010f\7\'"+
+		"\2\2\u010f\u0110\7n\2\2\u0110\u0111\7c\2\2\u0111\u0112\7w\2\2\u0112\u0113"+
+		"\7p\2\2\u0113\u0114\7e\2\2\u0114\u0115\7j\2\2\u0115\u0116\7g\2\2\u0116"+
+		"\u0117\7t\2\2\u0117\n\3\2\2\2\u0118\u0119\7\'\2\2\u0119\u011a\7|\2\2\u011a"+
+		"\u011b\7g\2\2\u011b\u011c\7t\2\2\u011c\u011d\7q\2\2\u011d\u011e\7r\2\2"+
+		"\u011e\u011f\7c\2\2\u011f\u0120\7i\2\2\u0120\u0121\7g\2\2\u0121\f\3\2"+
+		"\2\2\u0122\u0123\7\'\2\2\u0123\u0124\7|\2\2\u0124\u0125\7r\2\2\u0125\u0126"+
+		"\7t\2\2\u0126\u0127\7g\2\2\u0127\u0128\7u\2\2\u0128\u0129\7g\2\2\u0129"+
+		"\u012a\7t\2\2\u012a\u012b\7x\2\2\u012b\u012c\7g\2\2\u012c\u012d\7f\2\2"+
+		"\u012d\16\3\2\2\2\u012e\u012f\7\'\2\2\u012f\u0130\7c\2\2\u0130\u0131\7"+
+		"f\2\2\u0131\u0132\7f\2\2\u0132\u0133\7t\2\2\u0133\u0134\7g\2\2\u0134\u0135"+
+		"\7u\2\2\u0135\u0136\7u\2\2\u0136\20\3\2\2\2\u0137\u0138\7\'\2\2\u0138"+
+		"\u0139\7k\2\2\u0139\u013a\7o\2\2\u013a\u013b\7r\2\2\u013b\u013c\7q\2\2"+
+		"\u013c\u013d\7t\2\2\u013d\u013e\7v\2\2\u013e\22\3\2\2\2\u013f\u0140\7"+
+		"\'\2\2\u0140\u0141\7d\2\2\u0141\u0142\7t\2\2\u0142\u0143\7g\2\2\u0143"+
+		"\u0144\7c\2\2\u0144\u0145\7m\2\2\u0145\u0146\7r\2\2\u0146\u0147\7q\2\2"+
+		"\u0147\u0148\7k\2\2\u0148\u0149\7p\2\2\u0149\u014a\7v\2\2\u014a\24\3\2"+
+		"\2\2\u014b\u014c\7\'\2\2\u014c\u014d\7c\2\2\u014d\u014e\7u\2\2\u014e\u014f"+
+		"\7o\2\2\u014f\u0150\7k\2\2\u0150\u0151\7p\2\2\u0151\u0152\7e\2\2\u0152"+
+		"\u0153\7n\2\2\u0153\u0154\7w\2\2\u0154\u0155\7f\2\2\u0155\u0156\7g\2\2"+
+		"\u0156\26\3\2\2\2\u0157\u0158\7\'\2\2\u0158\u0159\7c\2\2\u0159\u015a\7"+
+		"u\2\2\u015a\u015b\7o\2\2\u015b\u015c\7d\2\2\u015c\u015d\7k\2\2\u015d\u015e"+
+		"\7p\2\2\u015e\u015f\7c\2\2\u015f\u0160\7t\2\2\u0160\u0161\7{\2\2\u0161"+
+		"\30\3\2\2\2\u0162\u0163\7\'\2\2\u0163\u0164\7q\2\2\u0164\u0165\7r\2\2"+
+		"\u0165\u0166\7v\2\2\u0166\u0167\7k\2\2\u0167\u0168\7q\2\2\u0168\u0169"+
+		"\7p\2\2\u0169\32\3\2\2\2\u016a\u016b\7.\2\2\u016b\34\3\2\2\2\u016c\u016d"+
+		"\7?\2\2\u016d\36\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171"+
+		"\7p\2\2\u0171\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173 \3\2\2\2\u0174\u0175"+
+		"\7u\2\2\u0175\u0176\7v\2\2\u0176\u0177\7t\2\2\u0177\u0178\7w\2\2\u0178"+
+		"\u0179\7e\2\2\u0179\u017a\7v\2\2\u017a\"\3\2\2\2\u017b\u017c\7}\2\2\u017c"+
+		"$\3\2\2\2\u017d\u017e\7\177\2\2\u017e&\3\2\2\2\u017f\u0180\7w\2\2\u0180"+
+		"\u0181\7d\2\2\u0181\u0182\7{\2\2\u0182\u0183\7v\2\2\u0183\u0184\7g\2\2"+
+		"\u0184(\3\2\2\2\u0185\u0186\7d\2\2\u0186\u0187\7{\2\2\u0187\u0188\7v\2"+
+		"\2\u0188\u0189\7g\2\2\u0189*\3\2\2\2\u018a\u018b\7w\2\2\u018b\u018c\7"+
+		"y\2\2\u018c\u018d\7q\2\2\u018d\u018e\7t\2\2\u018e\u018f\7f\2\2\u018f,"+
+		"\3\2\2\2\u0190\u0191\7y\2\2\u0191\u0192\7q\2\2\u0192\u0193\7t\2\2\u0193"+
+		"\u0194\7f\2\2\u0194.\3\2\2\2\u0195\u0196\7h\2\2\u0196\u0197\7n\2\2\u0197"+
+		"\u0198\7q\2\2\u0198\u0199\7c\2\2\u0199\u019a\7v\2\2\u019a\60\3\2\2\2\u019b"+
+		"\u019c\7u\2\2\u019c\u019d\7v\2\2\u019d\u019e\7t\2\2\u019e\62\3\2\2\2\u019f"+
+		"\u01a0\7]\2\2\u01a0\64\3\2\2\2\u01a1\u01a2\7_\2\2\u01a2\66\3\2\2\2\u01a3"+
+		"\u01a4\7-\2\2\u01a4\u01a5\7?\2\2\u01a58\3\2\2\2\u01a6\u01a7\7/\2\2\u01a7"+
+		"\u01a8\7?\2\2\u01a8:\3\2\2\2\u01a9\u01aa\7\61\2\2\u01aa\u01ab\7?\2\2\u01ab"+
+		"<\3\2\2\2\u01ac\u01ad\7,\2\2\u01ad\u01ae\7?\2\2\u01ae>\3\2\2\2\u01af\u01b0"+
+		"\7,\2\2\u01b0\u01b1\7,\2\2\u01b1\u01b2\7?\2\2\u01b2@\3\2\2\2\u01b3\u01b4"+
+		"\7(\2\2\u01b4\u01b5\7?\2\2\u01b5B\3\2\2\2\u01b6\u01b7\7~\2\2\u01b7\u01b8"+
+		"\7?\2\2\u01b8D\3\2\2\2\u01b9\u01ba\7`\2\2\u01ba\u01bb\7?\2\2\u01bbF\3"+
+		"\2\2\2\u01bc\u01bd\7\'\2\2\u01bd\u01be\7?\2\2\u01beH\3\2\2\2\u01bf\u01c0"+
+		"\7>\2\2\u01c0\u01c1\7>\2\2\u01c1\u01c2\7?\2\2\u01c2J\3\2\2\2\u01c3\u01c4"+
+		"\7@\2\2\u01c4\u01c5\7@\2\2\u01c5\u01c6\7?\2\2\u01c6L\3\2\2\2\u01c7\u01c8"+
+		"\7-\2\2\u01c8\u01c9\7-\2\2\u01c9N\3\2\2\2\u01ca\u01cb\7/\2\2\u01cb\u01cc"+
+		"\7/\2\2\u01ccP\3\2\2\2\u01cd\u01ce\7-\2\2\u01ceR\3\2\2\2\u01cf\u01d0\7"+
+		"/\2\2\u01d0T\3\2\2\2\u01d1\u01d2\7\u0080\2\2\u01d2V\3\2\2\2\u01d3\u01d4"+
+		"\7,\2\2\u01d4\u01d5\7,\2\2\u01d5X\3\2\2\2\u01d6\u01d7\7,\2\2\u01d7Z\3"+
+		"\2\2\2\u01d8\u01d9\7\61\2\2\u01d9\\\3\2\2\2\u01da\u01db\7\'\2\2\u01db"+
+		"^\3\2\2\2\u01dc\u01dd\7>\2\2\u01dd\u01de\7>\2\2\u01de`\3\2\2\2\u01df\u01e0"+
+		"\7@\2\2\u01e0\u01e1\7@\2\2\u01e1b\3\2\2\2\u01e2\u01e3\7>\2\2\u01e3d\3"+
+		"\2\2\2\u01e4\u01e5\7@\2\2\u01e5f\3\2\2\2\u01e6\u01e7\7>\2\2\u01e7\u01e8"+
+		"\7?\2\2\u01e8h\3\2\2\2\u01e9\u01ea\7@\2\2\u01ea\u01eb\7?\2\2\u01ebj\3"+
+		"\2\2\2\u01ec\u01ed\7?\2\2\u01ed\u01ee\7?\2\2\u01eel\3\2\2\2\u01ef\u01f0"+
+		"\7#\2\2\u01f0\u01f1\7?\2\2\u01f1n\3\2\2\2\u01f2\u01f3\7`\2\2\u01f3p\3"+
+		"\2\2\2\u01f4\u01f5\7~\2\2\u01f5r\3\2\2\2\u01f6\u01f7\7v\2\2\u01f7\u01f8"+
+		"\7q\2\2\u01f8t\3\2\2\2\u01f9\u01fa\7u\2\2\u01fa\u01fb\7v\2\2\u01fb\u01fc"+
+		"\7g\2\2\u01fc\u01fd\7r\2\2\u01fdv\3\2\2\2\u01fe\u01ff\7c\2\2\u01ff\u0200"+
+		"\7p\2\2\u0200\u0201\7f\2\2\u0201x\3\2\2\2\u0202\u0203\7q\2\2\u0203\u0204"+
+		"\7t\2\2\u0204z\3\2\2\2\u0205\u0206\7z\2\2\u0206\u0207\7q\2\2\u0207\u0208"+
+		"\7t\2\2\u0208|\3\2\2\2\u0209\u020a\7p\2\2\u020a\u020b\7q\2\2\u020b\u020c"+
+		"\7v\2\2\u020c~\3\2\2\2\u020d\u020e\7*\2\2\u020e\u0080\3\2\2\2\u020f\u0210"+
+		"\7+\2\2\u0210\u0082\3\2\2\2\u0211\u0212\7c\2\2\u0212\u0213\7u\2\2\u0213"+
+		"\u0084\3\2\2\2\u0214\u0215\7B\2\2\u0215\u0086\3\2\2\2\u0216\u0217\7t\2"+
+		"\2\u0217\u0218\7g\2\2\u0218\u0219\7v\2\2\u0219\u021a\7w\2\2\u021a\u021b"+
+		"\7t\2\2\u021b\u021c\7p\2\2\u021c\u0088\3\2\2\2\u021d\u021e\7d\2\2\u021e"+
+		"\u021f\7t\2\2\u021f\u0220\7g\2\2\u0220\u0221\7c\2\2\u0221\u0222\7m\2\2"+
+		"\u0222\u008a\3\2\2\2\u0223\u0224\7e\2\2\u0224\u0225\7q\2\2\u0225\u0226"+
+		"\7p\2\2\u0226\u0227\7v\2\2\u0227\u0228\7k\2\2\u0228\u0229\7p\2\2\u0229"+
+		"\u022a\7w\2\2\u022a\u022b\7g\2\2\u022b\u008c\3\2\2\2\u022c\u022d\7\60"+
+		"\2\2\u022d\u008e\3\2\2\2\u022e\u022f\7C\2\2\u022f\u0090\3\2\2\2\u0230"+
+		"\u0231\7Z\2\2\u0231\u0092\3\2\2\2\u0232\u0233\7[\2\2\u0233\u0094\3\2\2"+
+		"\2\u0234\u0235\7C\2\2\u0235\u0236\7Z\2\2\u0236\u0096\3\2\2\2\u0237\u0238"+
+		"\7C\2\2\u0238\u0239\7[\2\2\u0239\u0098\3\2\2\2\u023a\u023b\7Z\2\2\u023b"+
+		"\u023c\7[\2\2\u023c\u009a\3\2\2\2\u023d\u023e\7R\2\2\u023e\u023f\7e\2"+
+		"\2\u023f\u009c\3\2\2\2\u0240\u0241\7R\2\2\u0241\u0242\7|\2\2\u0242\u009e"+
+		"\3\2\2\2\u0243\u0244\7R\2\2\u0244\u0245\7p\2\2\u0245\u00a0\3\2\2\2\u0246"+
+		"\u0247\7R\2\2\u0247\u0248\7x\2\2\u0248\u00a2\3\2\2\2\u0249\u024a\7\60"+
+		"\2\2\u024a\u024b\7y\2\2\u024b\u00a4\3\2\2\2\u024c\u024d\7v\2\2\u024d\u024e"+
+		"\7t\2\2\u024e\u024f\7w\2\2\u024f\u0250\7g\2\2\u0250\u00a6\3\2\2\2\u0251"+
+		"\u0252\7h\2\2\u0252\u0253\7c\2\2\u0253\u0254\7n\2\2\u0254\u0255\7u\2\2"+
+		"\u0255\u0256\7g\2\2\u0256\u00a8\3\2\2\2\u0257\u0258\7\'\2\2\u0258\u0259"+
+		"\7c\2\2\u0259\u025a\7u\2\2\u025a\u025b\7o\2\2\u025b\u00aa\3\2\2\2\u025c"+
+		"\u025d\7u\2\2\u025d\u025e\7w\2\2\u025e\u025f\7d\2\2\u025f\u00ac\3\2\2"+
+		"\2\u0260\u0261\7/\2\2\u0261\u0262\7@\2\2\u0262\u00ae\3\2\2\2\u0263\u0264"+
+		"\7c\2\2\u0264\u0265\7u\2\2\u0265\u0266\7o\2\2\u0266\u0267\7u\2\2\u0267"+
+		"\u0268\7w\2\2\u0268\u0269\7d\2\2\u0269\u00b0\3\2\2\2\u026a\u026b\7u\2"+
+		"\2\u026b\u026c\7v\2\2\u026c\u026d\7c\2\2\u026d\u026e\7e\2\2\u026e\u026f"+
+		"\7m\2\2\u026f\u00b2\3\2\2\2\u0270\u0271\7e\2\2\u0271\u0272\7n\2\2\u0272"+
+		"\u0273\7q\2\2\u0273\u0274\7d\2\2\u0274\u0275\7d\2\2\u0275\u0276\7g\2\2"+
+		"\u0276\u0277\7t\2\2\u0277\u0278\7u\2\2\u0278\u00b4\3\2\2\2\u0279\u027a"+
+		"\7k\2\2\u027a\u027b\7h\2\2\u027b\u00b6\3\2\2\2\u027c\u027d\7g\2\2\u027d"+
+		"\u027e\7n\2\2\u027e\u027f\7u\2\2\u027f\u0280\7g\2\2\u0280\u00b8\3\2\2"+
+		"\2\u0281\u0282\7k\2\2\u0282\u0283\7h\2\2\u0283\u0284\7a\2\2\u0284\u0285"+
+		"\7e\2\2\u0285\u0286\7u\2\2\u0286\u00ba\3\2\2\2\u0287\u0288\7k\2\2\u0288"+
+		"\u0289\7h\2\2\u0289\u028a\7a\2\2\u028a\u028b\7e\2\2\u028b\u028c\7e\2\2"+
+		"\u028c\u00bc\3\2\2\2\u028d\u028e\7k\2\2\u028e\u028f\7h\2\2\u028f\u0290"+
+		"\7a\2\2\u0290\u0291\7g\2\2\u0291\u0292\7s\2\2\u0292\u00be\3\2\2\2\u0293"+
+		"\u0294\7k\2\2\u0294\u0295\7h\2\2\u0295\u0296\7a\2\2\u0296\u0297\7|\2\2"+
+		"\u0297\u00c0\3\2\2\2\u0298\u0299\7k\2\2\u0299\u029a\7h\2\2\u029a\u029b"+
+		"\7a\2\2\u029b\u029c\7p\2\2\u029c\u029d\7g\2\2\u029d\u00c2\3\2\2\2\u029e"+
+		"\u029f\7k\2\2\u029f\u02a0\7h\2\2\u02a0\u02a1\7a\2\2\u02a1\u02a2\7p\2\2"+
+		"\u02a2\u02a3\7|\2\2\u02a3\u00c4\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6"+
+		"\7h\2\2\u02a6\u02a7\7a\2\2\u02a7\u02a8\7r\2\2\u02a8\u02a9\7n\2\2\u02a9"+
+		"\u00c6\3\2\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7a\2"+
+		"\2\u02ad\u02ae\7r\2\2\u02ae\u02af\7q\2\2\u02af\u02b0\7u\2\2\u02b0\u00c8"+
+		"\3\2\2\2\u02b1\u02b2\7k\2\2\u02b2\u02b3\7h\2\2\u02b3\u02b4\7a\2\2\u02b4"+
+		"\u02b5\7o\2\2\u02b5\u02b6\7k\2\2\u02b6\u00ca\3\2\2\2\u02b7\u02b8\7k\2"+
+		"\2\u02b8\u02b9\7h\2\2\u02b9\u02ba\7a\2\2\u02ba\u02bb\7p\2\2\u02bb\u02bc"+
+		"\7g\2\2\u02bc\u02bd\7i\2\2\u02bd\u00cc\3\2\2\2\u02be\u02bf\7k\2\2\u02bf"+
+		"\u02c0\7h\2\2\u02c0\u02c1\7a\2\2\u02c1\u02c2\7x\2\2\u02c2\u02c3\7u\2\2"+
+		"\u02c3\u00ce\3\2\2\2\u02c4\u02c5\7k\2\2\u02c5\u02c6\7h\2\2\u02c6\u02c7"+
+		"\7a\2\2\u02c7\u02c8\7x\2\2\u02c8\u02c9\7e\2\2\u02c9\u00d0\3\2\2\2\u02ca"+
+		"\u02cb\7h\2\2\u02cb\u02cc\7q\2\2\u02cc\u02cd\7t\2\2\u02cd\u00d2\3\2\2"+
+		"\2\u02ce\u02cf\7k\2\2\u02cf\u02d0\7p\2\2\u02d0\u00d4\3\2\2\2\u02d1\u02d2"+
+		"\7y\2\2\u02d2\u02d3\7j\2\2\u02d3\u02d4\7k\2\2\u02d4\u02d5\7n\2\2\u02d5"+
+		"\u02d6\7g\2\2\u02d6\u00d6\3\2\2\2\u02d7\u02d8\7t\2\2\u02d8\u02d9\7g\2"+
+		"\2\u02d9\u02da\7r\2\2\u02da\u02db\7g\2\2\u02db\u02dc\7c\2\2\u02dc\u02dd"+
+		"\7v\2\2\u02dd\u00d8\3\2\2\2\u02de\u02df\7w\2\2\u02df\u02e0\7p\2\2\u02e0"+
+		"\u02e1\7v\2\2\u02e1\u02e2\7k\2\2\u02e2\u02e3\7n\2\2\u02e3\u00da\3\2\2"+
+		"\2\u02e4\u02e5\7y\2\2\u02e5\u02e6\7j\2\2\u02e6\u02e7\7g\2\2\u02e7\u02e8"+
+		"\7p\2\2\u02e8\u00dc\3\2\2\2\u02e9\u02ed\t\2\2\2\u02ea\u02ec\t\3\2\2\u02eb"+
+		"\u02ea\3\2\2\2\u02ec\u02ef\3\2\2\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2"+
+		"\2\2\u02ee\u02f0\3\2\2\2\u02ef\u02ed\3\2\2\2\u02f0\u02f1\5\u00dfp\2\u02f1"+
+		"\u02f2\3\2\2\2\u02f2\u02f3\bo\2\2\u02f3\u00de\3\2\2\2\u02f4\u02f8\7=\2"+
+		"\2\u02f5\u02f7\n\2\2\2\u02f6\u02f5\3\2\2\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6"+
+		"\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fb\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb"+
+		"\u02fc\bp\2\2\u02fc\u00e0\3\2\2\2\u02fd\u02fe\t\3\2\2\u02fe\u02ff\3\2"+
+		"\2\2\u02ff\u0300\bq\3\2\u0300\u00e2\3\2\2\2\u0301\u0303\t\2\2\2\u0302"+
+		"\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2"+
+		"\2\2\u0305\u00e4\3\2\2\2\u0306\u030a\t\4\2\2\u0307\u0309\t\5\2\2\u0308"+
+		"\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2"+
+		"\2\2\u030b\u00e6\3\2\2\2\u030c\u030a\3\2\2\2\u030d\u0315\4\62;\2\u030e"+
+		"\u0310\4\63;\2\u030f\u0311\4\62;\2\u0310\u030f\3\2\2\2\u0311\u0312\3\2"+
+		"\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0315\3\2\2\2\u0314"+
+		"\u030d\3\2\2\2\u0314\u030e\3\2\2\2\u0315\u00e8\3\2\2\2\u0316\u0318\7&"+
+		"\2\2\u0317\u0319\t\6\2\2\u0318\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a"+
+		"\u0318\3\2\2\2\u031a\u031b\3\2\2\2\u031b\u00ea\3\2\2\2\u031c\u031e\7\'"+
+		"\2\2\u031d\u031f\4\62\63\2\u031e\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+
+		"\u031e\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u00ec\3\2\2\2\u0322\u0323\7("+
+		"\2\2\u0323\u00ee\3\2\2\2\u0324\u032a\5\u00f1y\2\u0325\u0327\t\7\2\2\u0326"+
+		"\u0328\t\b\2\2\u0327\u0326\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\3\2"+
+		"\2\2\u0329\u032b\5\u00f1y\2\u032a\u0325\3\2\2\2\u032a\u032b\3\2\2\2\u032b"+
+		"\u00f0\3\2\2\2\u032c\u032e\4\62;\2\u032d\u032c\3\2\2\2\u032e\u032f\3\2"+
+		"\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0337\3\2\2\2\u0331"+
+		"\u0333\7\60\2\2\u0332\u0334\4\62;\2\u0333\u0332\3\2\2\2\u0334\u0335\3"+
+		"\2\2\2\u0335\u0333\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0338\3\2\2\2\u0337"+
+		"\u0331\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u00f2\3\2\2\2\u0339\u033a\7^"+
+		"\2\2\u033a\u033e\13\2\2\2\u033b\u033c\7^\2\2\u033c\u033e\5\u00e3r\2\u033d"+
+		"\u0339\3\2\2\2\u033d\u033b\3\2\2\2\u033e\u00f4\3\2\2\2\u033f\u0344\7$"+
+		"\2\2\u0340\u0343\5\u00f3z\2\u0341\u0343\n\t\2\2\u0342\u0340\3\2\2\2\u0342"+
+		"\u0341\3\2\2\2\u0343\u0346\3\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2"+
+		"\2\2\u0345\u0347\3\2\2\2\u0346\u0344\3\2\2\2\u0347\u0348\7$\2\2\u0348"+
+		"\u0349\b{\4\2\u0349\u00f6\3\2\2\2\u034a\u034b\7}\2\2\u034b\u034c\7}\2"+
+		"\2\u034c\u034e\3\2\2\2\u034d\u034f\13\2\2\2\u034e\u034d\3\2\2\2\u034f"+
+		"\u0350\3\2\2\2\u0350\u0351\3\2\2\2\u0350\u034e\3\2\2\2\u0351\u0352\3\2"+
+		"\2\2\u0352\u0353\7\177\2\2\u0353\u0354\7\177\2\2\u0354\u0355\3\2\2\2\u0355"+
+		"\u0356\b|\5\2\u0356\u00f8\3\2\2\2\u0357\u035a\7)\2\2\u0358\u035b\5\u00f3"+
+		"z\2\u0359\u035b\n\t\2\2\u035a\u0358\3\2\2\2\u035a\u0359\3\2\2\2\u035b"+
+		"\u035c\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\b}\6\2\u035e\u00fa\3\2\2"+
+		"\2\u035f\u0360\7B\2\2\u0360\u0361\7|\2\2\u0361\u0362\7r\2\2\u0362\u00fc"+
+		"\3\2\2\2\u0363\u0364\7]\2\2\u0364\u0365\7_\2\2\u0365\u00fe\3\2\2\2\26"+
+		"\2\u02ed\u02f8\u0304\u030a\u0312\u0314\u0318\u031a\u0320\u0327\u032a\u032f"+
+		"\u0335\u0337\u033d\u0342\u0344\u0350\u035a\7\2\3\2\b\2\2\3{\2\3|\3\3}"+
+		"\4";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {
diff --git a/parser/src/prog8/parser/prog8Parser.java b/parser/src/prog8/parser/prog8Parser.java
index 21149afac..f19a18834 100644
--- a/parser/src/prog8/parser/prog8Parser.java
+++ b/parser/src/prog8/parser/prog8Parser.java
@@ -34,10 +34,10 @@ public class prog8Parser extends Parser {
 		T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, 
 		T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, 
 		T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, 
-		T__107=108, T__108=109, T__109=110, LINECOMMENT=111, COMMENT=112, WS=113, 
-		EOL=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, 
-		ADDRESS_OF=119, FLOAT_NUMBER=120, STRING=121, INLINEASMBLOCK=122, SINGLECHAR=123, 
-		ZEROPAGE=124, ARRAYSIG=125;
+		T__107=108, T__108=109, LINECOMMENT=110, COMMENT=111, WS=112, EOL=113, 
+		NAME=114, DEC_INTEGER=115, HEX_INTEGER=116, BIN_INTEGER=117, ADDRESS_OF=118, 
+		FLOAT_NUMBER=119, STRING=120, INLINEASMBLOCK=121, SINGLECHAR=122, ZEROPAGE=123, 
+		ARRAYSIG=124;
 	public static final int
 		RULE_module = 0, RULE_modulestatement = 1, RULE_block = 2, RULE_statement = 3, 
 		RULE_labeldef = 4, RULE_unconditionaljump = 5, RULE_directive = 6, RULE_directivearg = 7, 
@@ -85,19 +85,19 @@ public class prog8Parser extends Parser {
 			null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'", 
 			"'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'", 
 			"'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'", 
-			"'byte'", "'uword'", "'word'", "'float'", "'str'", "'str_s'", "'['", 
-			"']'", "'+='", "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", 
-			"'%='", "'<<='", "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", 
-			"'*'", "'/'", "'%'", "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", 
-			"'!='", "'^'", "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", 
-			"'('", "')'", "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", 
-			"'A'", "'X'", "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", 
-			"'Pv'", "'.w'", "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", 
-			"'stack'", "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", 
-			"'if_z'", "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", 
-			"'if_vs'", "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", 
-			"'when'", null, null, null, null, null, null, null, null, "'&'", null, 
-			null, null, null, "'@zp'", "'[]'"
+			"'byte'", "'uword'", "'word'", "'float'", "'str'", "'['", "']'", "'+='", 
+			"'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='", 
+			"'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'*'", "'/'", "'%'", 
+			"'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'", 
+			"'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'", 
+			"'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'A'", "'X'", 
+			"'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'", 
+			"'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'stack'", 
+			"'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'", 
+			"'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'", 
+			"'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'when'", 
+			null, null, null, null, null, null, null, null, "'&'", null, null, null, 
+			null, "'@zp'", "'[]'"
 		};
 	}
 	private static final String[] _LITERAL_NAMES = makeLiteralNames();
@@ -112,7 +112,7 @@ public class prog8Parser extends Parser {
 			null, null, null, null, null, null, null, null, null, null, null, null, 
 			null, null, null, null, null, null, null, null, null, null, null, null, 
 			null, null, null, null, null, null, null, null, null, null, null, null, 
-			null, null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", 
+			null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", 
 			"HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", 
 			"INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
 		};
@@ -333,7 +333,7 @@ public class prog8Parser extends Parser {
 			setState(153);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) {
+			if (((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & ((1L << (DEC_INTEGER - 115)) | (1L << (HEX_INTEGER - 115)) | (1L << (BIN_INTEGER - 115)))) != 0)) {
 				{
 				setState(152);
 				integerliteral();
@@ -918,7 +918,7 @@ public class prog8Parser extends Parser {
 			setState(219);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
-			case T__25:
+			case T__24:
 				{
 				setState(217);
 				arrayindex();
@@ -1230,7 +1230,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(258);
 			_la = _input.LA(1);
-			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24))) != 0)) ) {
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -1268,11 +1268,11 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(260);
-			match(T__25);
+			match(T__24);
 			setState(261);
 			expression(0);
 			setState(262);
-			match(T__26);
+			match(T__25);
 			}
 		}
 		catch (RecognitionException re) {
@@ -1350,7 +1350,7 @@ public class prog8Parser extends Parser {
 			setState(269);
 			((AugassignmentContext)_localctx).operator = _input.LT(1);
 			_la = _input.LA(1);
-			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36) | (1L << T__37))) != 0)) ) {
+			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36))) != 0)) ) {
 				((AugassignmentContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
 			}
 			else {
@@ -1463,7 +1463,7 @@ public class prog8Parser extends Parser {
 			setState(279);
 			((PostincrdecrContext)_localctx).operator = _input.LT(1);
 			_la = _input.LA(1);
-			if ( !(_la==T__38 || _la==T__39) ) {
+			if ( !(_la==T__37 || _la==T__38) ) {
 				((PostincrdecrContext)_localctx).operator = (Token)_errHandler.recoverInline(this);
 			}
 			else {
@@ -1563,7 +1563,7 @@ public class prog8Parser extends Parser {
 				setState(283);
 				((ExpressionContext)_localctx).prefix = _input.LT(1);
 				_la = _input.LA(1);
-				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__40) | (1L << T__41) | (1L << T__42))) != 0)) ) {
+				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__39) | (1L << T__40) | (1L << T__41))) != 0)) ) {
 					((ExpressionContext)_localctx).prefix = (Token)_errHandler.recoverInline(this);
 				}
 				else {
@@ -1578,7 +1578,7 @@ public class prog8Parser extends Parser {
 			case 3:
 				{
 				setState(285);
-				((ExpressionContext)_localctx).prefix = match(T__62);
+				((ExpressionContext)_localctx).prefix = match(T__61);
 				setState(286);
 				expression(9);
 				}
@@ -1622,11 +1622,11 @@ public class prog8Parser extends Parser {
 			case 10:
 				{
 				setState(293);
-				match(T__63);
+				match(T__62);
 				setState(294);
 				expression(0);
 				setState(295);
-				match(T__64);
+				match(T__63);
 				}
 				break;
 			}
@@ -1661,7 +1661,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(303);
-						((ExpressionContext)_localctx).bop = match(T__43);
+						((ExpressionContext)_localctx).bop = match(T__42);
 						setState(305);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -1697,7 +1697,7 @@ public class prog8Parser extends Parser {
 						setState(312);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
-						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__44) | (1L << T__45) | (1L << T__46))) != 0)) ) {
+						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__43) | (1L << T__44) | (1L << T__45))) != 0)) ) {
 							((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
 						}
 						else {
@@ -1740,7 +1740,7 @@ public class prog8Parser extends Parser {
 						setState(321);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
-						if ( !(_la==T__40 || _la==T__41) ) {
+						if ( !(_la==T__39 || _la==T__40) ) {
 							((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
 						}
 						else {
@@ -1783,7 +1783,7 @@ public class prog8Parser extends Parser {
 						setState(330);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
-						if ( !(_la==T__47 || _la==T__48) ) {
+						if ( !(_la==T__46 || _la==T__47) ) {
 							((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
 						}
 						else {
@@ -1826,7 +1826,7 @@ public class prog8Parser extends Parser {
 						setState(339);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
-						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__49) | (1L << T__50) | (1L << T__51) | (1L << T__52))) != 0)) ) {
+						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51))) != 0)) ) {
 							((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
 						}
 						else {
@@ -1869,7 +1869,7 @@ public class prog8Parser extends Parser {
 						setState(348);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
-						if ( !(_la==T__53 || _la==T__54) ) {
+						if ( !(_la==T__52 || _la==T__53) ) {
 							((ExpressionContext)_localctx).bop = (Token)_errHandler.recoverInline(this);
 						}
 						else {
@@ -1944,7 +1944,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(366);
-						((ExpressionContext)_localctx).bop = match(T__55);
+						((ExpressionContext)_localctx).bop = match(T__54);
 						setState(368);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -1978,7 +1978,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(375);
-						((ExpressionContext)_localctx).bop = match(T__56);
+						((ExpressionContext)_localctx).bop = match(T__55);
 						setState(377);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -2012,7 +2012,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(384);
-						((ExpressionContext)_localctx).bop = match(T__59);
+						((ExpressionContext)_localctx).bop = match(T__58);
 						setState(386);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -2046,7 +2046,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(393);
-						((ExpressionContext)_localctx).bop = match(T__60);
+						((ExpressionContext)_localctx).bop = match(T__59);
 						setState(395);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -2080,7 +2080,7 @@ public class prog8Parser extends Parser {
 						}
 
 						setState(402);
-						((ExpressionContext)_localctx).bop = match(T__61);
+						((ExpressionContext)_localctx).bop = match(T__60);
 						setState(404);
 						_errHandler.sync(this);
 						_la = _input.LA(1);
@@ -2104,7 +2104,7 @@ public class prog8Parser extends Parser {
 						setState(407);
 						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
 						setState(408);
-						match(T__57);
+						match(T__56);
 						setState(409);
 						((ExpressionContext)_localctx).rangeto = expression(0);
 						setState(412);
@@ -2113,7 +2113,7 @@ public class prog8Parser extends Parser {
 						case 1:
 							{
 							setState(410);
-							match(T__58);
+							match(T__57);
 							setState(411);
 							((ExpressionContext)_localctx).rangestep = expression(0);
 							}
@@ -2168,7 +2168,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(421);
-			match(T__65);
+			match(T__64);
 			setState(422);
 			datatype();
 			}
@@ -2237,13 +2237,13 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(427);
-			match(T__66);
+			match(T__65);
 			setState(428);
-			match(T__63);
+			match(T__62);
 			setState(429);
 			expression(0);
 			setState(430);
-			match(T__64);
+			match(T__63);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2314,11 +2314,11 @@ public class prog8Parser extends Parser {
 			setState(435);
 			scoped_identifier();
 			setState(436);
-			match(T__63);
+			match(T__62);
 			setState(438);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__25) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__66 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (NAME - 64)) | (1L << (DEC_INTEGER - 64)) | (1L << (HEX_INTEGER - 64)) | (1L << (BIN_INTEGER - 64)) | (1L << (ADDRESS_OF - 64)) | (1L << (FLOAT_NUMBER - 64)) | (1L << (STRING - 64)) | (1L << (SINGLECHAR - 64)))) != 0)) {
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) {
 				{
 				setState(437);
 				expression_list();
@@ -2326,7 +2326,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(440);
-			match(T__64);
+			match(T__63);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2363,11 +2363,11 @@ public class prog8Parser extends Parser {
 			setState(442);
 			scoped_identifier();
 			setState(443);
-			match(T__63);
+			match(T__62);
 			setState(445);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__25) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__66 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (NAME - 64)) | (1L << (DEC_INTEGER - 64)) | (1L << (HEX_INTEGER - 64)) | (1L << (BIN_INTEGER - 64)) | (1L << (ADDRESS_OF - 64)) | (1L << (FLOAT_NUMBER - 64)) | (1L << (STRING - 64)) | (1L << (SINGLECHAR - 64)))) != 0)) {
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) {
 				{
 				setState(444);
 				expression_list();
@@ -2375,7 +2375,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(447);
-			match(T__64);
+			match(T__63);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2471,7 +2471,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(460);
-			match(T__67);
+			match(T__66);
 			setState(462);
 			_errHandler.sync(this);
 			switch ( getInterpreter().adaptivePredict(_input,47,_ctx) ) {
@@ -2509,7 +2509,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(464);
-			match(T__68);
+			match(T__67);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2537,7 +2537,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(466);
-			match(T__69);
+			match(T__68);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2608,7 +2608,7 @@ public class prog8Parser extends Parser {
 					{
 					{
 					setState(471);
-					match(T__70);
+					match(T__69);
 					setState(472);
 					match(NAME);
 					}
@@ -2647,7 +2647,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(478);
 			_la = _input.LA(1);
-			if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (T__71 - 72)) | (1L << (T__72 - 72)) | (1L << (T__73 - 72)))) != 0)) ) {
+			if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -2684,7 +2684,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(480);
 			_la = _input.LA(1);
-			if ( !(((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (T__71 - 72)) | (1L << (T__72 - 72)) | (1L << (T__73 - 72)) | (1L << (T__74 - 72)) | (1L << (T__75 - 72)) | (1L << (T__76 - 72)))) != 0)) ) {
+			if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)) | (1L << (T__73 - 71)) | (1L << (T__74 - 71)) | (1L << (T__75 - 71)))) != 0)) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -2721,7 +2721,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(482);
 			_la = _input.LA(1);
-			if ( !(((((_la - 78)) & ~0x3f) == 0 && ((1L << (_la - 78)) & ((1L << (T__77 - 78)) | (1L << (T__78 - 78)) | (1L << (T__79 - 78)) | (1L << (T__80 - 78)))) != 0)) ) {
+			if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (T__76 - 77)) | (1L << (T__77 - 77)) | (1L << (T__78 - 77)) | (1L << (T__79 - 77)))) != 0)) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -2766,7 +2766,7 @@ public class prog8Parser extends Parser {
 			setState(484);
 			((IntegerliteralContext)_localctx).intpart = _input.LT(1);
 			_la = _input.LA(1);
-			if ( !(((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) ) {
+			if ( !(((((_la - 115)) & ~0x3f) == 0 && ((1L << (_la - 115)) & ((1L << (DEC_INTEGER - 115)) | (1L << (HEX_INTEGER - 115)) | (1L << (BIN_INTEGER - 115)))) != 0)) ) {
 				((IntegerliteralContext)_localctx).intpart = (Token)_errHandler.recoverInline(this);
 			}
 			else {
@@ -2811,7 +2811,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(488);
-			match(T__81);
+			match(T__80);
 			}
 		}
 		catch (RecognitionException re) {
@@ -2841,7 +2841,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(490);
 			_la = _input.LA(1);
-			if ( !(_la==T__82 || _la==T__83) ) {
+			if ( !(_la==T__81 || _la==T__82) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -2887,7 +2887,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(492);
-			match(T__25);
+			match(T__24);
 			setState(494);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
@@ -2937,7 +2937,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(510);
-			match(T__26);
+			match(T__25);
 			}
 		}
 		catch (RecognitionException re) {
@@ -3171,15 +3171,15 @@ public class prog8Parser extends Parser {
 				integerliteral();
 				}
 				break;
+			case T__81:
 			case T__82:
-			case T__83:
 				enterOuterAlt(_localctx, 2);
 				{
 				setState(539);
 				booleanliteral();
 				}
 				break;
-			case T__25:
+			case T__24:
 				enterOuterAlt(_localctx, 3);
 				{
 				setState(540);
@@ -3244,7 +3244,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(547);
-			match(T__84);
+			match(T__83);
 			setState(548);
 			match(INLINEASMBLOCK);
 			}
@@ -3288,15 +3288,15 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(550);
-			match(T__85);
+			match(T__84);
 			setState(551);
 			identifier();
 			setState(552);
-			match(T__63);
+			match(T__62);
 			setState(554);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24))) != 0)) {
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) {
 				{
 				setState(553);
 				sub_params();
@@ -3304,11 +3304,11 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(556);
-			match(T__64);
+			match(T__63);
 			setState(558);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (_la==T__86) {
+			if (_la==T__85) {
 				{
 				setState(557);
 				sub_return_part();
@@ -3351,7 +3351,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(563);
-			match(T__86);
+			match(T__85);
 			setState(564);
 			sub_returns();
 			}
@@ -3398,7 +3398,7 @@ public class prog8Parser extends Parser {
 			setState(572);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__14) | (1L << T__15) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24))) != 0) || ((((_la - 67)) & ~0x3f) == 0 && ((1L << (_la - 67)) & ((1L << (T__66 - 67)) | (1L << (T__67 - 67)) | (1L << (T__68 - 67)) | (1L << (T__69 - 67)) | (1L << (T__71 - 67)) | (1L << (T__72 - 67)) | (1L << (T__73 - 67)) | (1L << (T__84 - 67)) | (1L << (T__85 - 67)) | (1L << (T__87 - 67)) | (1L << (T__90 - 67)) | (1L << (T__92 - 67)) | (1L << (T__93 - 67)) | (1L << (T__94 - 67)) | (1L << (T__95 - 67)) | (1L << (T__96 - 67)) | (1L << (T__97 - 67)) | (1L << (T__98 - 67)) | (1L << (T__99 - 67)) | (1L << (T__100 - 67)) | (1L << (T__101 - 67)) | (1L << (T__102 - 67)) | (1L << (T__103 - 67)) | (1L << (T__104 - 67)) | (1L << (T__106 - 67)) | (1L << (T__107 - 67)) | (1L << (T__109 - 67)) | (1L << (EOL - 67)) | (1L << (NAME - 67)) | (1L << (ADDRESS_OF - 67)))) != 0)) {
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__1) | (1L << T__2) | (1L << T__3) | (1L << T__4) | (1L << T__5) | (1L << T__6) | (1L << T__7) | (1L << T__8) | (1L << T__9) | (1L << T__10) | (1L << T__11) | (1L << T__14) | (1L << T__15) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__66 - 66)) | (1L << (T__67 - 66)) | (1L << (T__68 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__83 - 66)) | (1L << (T__84 - 66)) | (1L << (T__86 - 66)) | (1L << (T__89 - 66)) | (1L << (T__91 - 66)) | (1L << (T__92 - 66)) | (1L << (T__93 - 66)) | (1L << (T__94 - 66)) | (1L << (T__95 - 66)) | (1L << (T__96 - 66)) | (1L << (T__97 - 66)) | (1L << (T__98 - 66)) | (1L << (T__99 - 66)) | (1L << (T__100 - 66)) | (1L << (T__101 - 66)) | (1L << (T__102 - 66)) | (1L << (T__103 - 66)) | (1L << (T__105 - 66)) | (1L << (T__106 - 66)) | (1L << (T__108 - 66)) | (1L << (EOL - 66)) | (1L << (NAME - 66)) | (1L << (ADDRESS_OF - 66)))) != 0)) {
 				{
 				setState(570);
 				_errHandler.sync(this);
@@ -3422,18 +3422,18 @@ public class prog8Parser extends Parser {
 				case T__21:
 				case T__22:
 				case T__23:
-				case T__24:
+				case T__65:
 				case T__66:
 				case T__67:
 				case T__68:
-				case T__69:
+				case T__70:
 				case T__71:
 				case T__72:
-				case T__73:
+				case T__83:
 				case T__84:
-				case T__85:
-				case T__87:
-				case T__90:
+				case T__86:
+				case T__89:
+				case T__91:
 				case T__92:
 				case T__93:
 				case T__94:
@@ -3446,10 +3446,9 @@ public class prog8Parser extends Parser {
 				case T__101:
 				case T__102:
 				case T__103:
-				case T__104:
+				case T__105:
 				case T__106:
-				case T__107:
-				case T__109:
+				case T__108:
 				case NAME:
 				case ADDRESS_OF:
 					{
@@ -3650,15 +3649,15 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(599);
-			match(T__87);
+			match(T__86);
 			setState(600);
 			identifier();
 			setState(601);
-			match(T__63);
+			match(T__62);
 			setState(603);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24))) != 0)) {
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23))) != 0)) {
 				{
 				setState(602);
 				asmsub_params();
@@ -3666,7 +3665,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(605);
-			match(T__64);
+			match(T__63);
 			setState(607);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
@@ -3680,7 +3679,7 @@ public class prog8Parser extends Parser {
 			setState(610);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (_la==T__89) {
+			if (_la==T__88) {
 				{
 				setState(609);
 				asmsub_clobbers();
@@ -3690,7 +3689,7 @@ public class prog8Parser extends Parser {
 			setState(613);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (_la==T__86) {
+			if (_la==T__85) {
 				{
 				setState(612);
 				asmsub_returns();
@@ -3853,34 +3852,34 @@ public class prog8Parser extends Parser {
 			setState(633);
 			vardecl();
 			setState(634);
-			match(T__66);
+			match(T__65);
 			setState(638);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
+			case T__70:
 			case T__71:
 			case T__72:
 			case T__73:
 			case T__74:
 			case T__75:
-			case T__76:
 				{
 				setState(635);
 				registerorpair();
 				}
 				break;
+			case T__76:
 			case T__77:
 			case T__78:
 			case T__79:
-			case T__80:
 				{
 				setState(636);
 				statusregister();
 				}
 				break;
-			case T__88:
+			case T__87:
 				{
 				setState(637);
-				((Asmsub_paramContext)_localctx).stack = match(T__88);
+				((Asmsub_paramContext)_localctx).stack = match(T__87);
 				}
 				break;
 			default:
@@ -3917,13 +3916,13 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(640);
-			match(T__89);
+			match(T__88);
 			setState(641);
-			match(T__63);
+			match(T__62);
 			setState(643);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (((((_la - 72)) & ~0x3f) == 0 && ((1L << (_la - 72)) & ((1L << (T__71 - 72)) | (1L << (T__72 - 72)) | (1L << (T__73 - 72)))) != 0)) {
+			if (((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) {
 				{
 				setState(642);
 				clobber();
@@ -3931,7 +3930,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(645);
-			match(T__64);
+			match(T__63);
 			}
 		}
 		catch (RecognitionException re) {
@@ -4021,7 +4020,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(655);
-			match(T__86);
+			match(T__85);
 			setState(656);
 			asmsub_return();
 			setState(664);
@@ -4089,34 +4088,34 @@ public class prog8Parser extends Parser {
 			setState(667);
 			datatype();
 			setState(668);
-			match(T__66);
+			match(T__65);
 			setState(672);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
+			case T__70:
 			case T__71:
 			case T__72:
 			case T__73:
 			case T__74:
 			case T__75:
-			case T__76:
 				{
 				setState(669);
 				registerorpair();
 				}
 				break;
+			case T__76:
 			case T__77:
 			case T__78:
 			case T__79:
-			case T__80:
 				{
 				setState(670);
 				statusregister();
 				}
 				break;
-			case T__88:
+			case T__87:
 				{
 				setState(671);
-				((Asmsub_returnContext)_localctx).stack = match(T__88);
+				((Asmsub_returnContext)_localctx).stack = match(T__87);
 				}
 				break;
 			default:
@@ -4166,7 +4165,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(674);
-			match(T__90);
+			match(T__89);
 			setState(675);
 			expression(0);
 			setState(677);
@@ -4201,18 +4200,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4225,10 +4224,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4300,7 +4298,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(689);
-			match(T__91);
+			match(T__90);
 			setState(691);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
@@ -4333,18 +4331,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4357,10 +4355,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4454,18 +4451,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4478,10 +4475,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4511,7 +4507,7 @@ public class prog8Parser extends Parser {
 			setState(709);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			if (_la==T__91) {
+			if (_la==T__90) {
 				{
 				setState(708);
 				else_part();
@@ -4549,7 +4545,7 @@ public class prog8Parser extends Parser {
 			{
 			setState(713);
 			_la = _input.LA(1);
-			if ( !(((((_la - 93)) & ~0x3f) == 0 && ((1L << (_la - 93)) & ((1L << (T__92 - 93)) | (1L << (T__93 - 93)) | (1L << (T__94 - 93)) | (1L << (T__95 - 93)) | (1L << (T__96 - 93)) | (1L << (T__97 - 93)) | (1L << (T__98 - 93)) | (1L << (T__99 - 93)) | (1L << (T__100 - 93)) | (1L << (T__101 - 93)) | (1L << (T__102 - 93)) | (1L << (T__103 - 93)))) != 0)) ) {
+			if ( !(((((_la - 92)) & ~0x3f) == 0 && ((1L << (_la - 92)) & ((1L << (T__91 - 92)) | (1L << (T__92 - 92)) | (1L << (T__93 - 92)) | (1L << (T__94 - 92)) | (1L << (T__95 - 92)) | (1L << (T__96 - 92)) | (1L << (T__97 - 92)) | (1L << (T__98 - 92)) | (1L << (T__99 - 92)) | (1L << (T__100 - 92)) | (1L << (T__101 - 92)) | (1L << (T__102 - 92)))) != 0)) ) {
 			_errHandler.recoverInline(this);
 			}
 			else {
@@ -4601,13 +4597,13 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(715);
-			match(T__104);
+			match(T__103);
 			setState(718);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
 				{
 				setState(716);
 				register();
@@ -4623,7 +4619,7 @@ public class prog8Parser extends Parser {
 				throw new NoViableAltException(this);
 			}
 			setState(720);
-			match(T__105);
+			match(T__104);
 			setState(721);
 			expression(0);
 			setState(723);
@@ -4658,18 +4654,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4682,10 +4678,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4740,7 +4735,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(729);
-			match(T__106);
+			match(T__105);
 			setState(730);
 			expression(0);
 			setState(732);
@@ -4775,18 +4770,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4799,10 +4794,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4857,7 +4851,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(738);
-			match(T__107);
+			match(T__106);
 			setState(741);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
@@ -4880,18 +4874,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -4904,10 +4898,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -4935,7 +4928,7 @@ public class prog8Parser extends Parser {
 			}
 
 			setState(746);
-			match(T__108);
+			match(T__107);
 			setState(747);
 			expression(0);
 			}
@@ -4979,7 +4972,7 @@ public class prog8Parser extends Parser {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(749);
-			match(T__109);
+			match(T__108);
 			setState(750);
 			expression(0);
 			setState(751);
@@ -4989,25 +4982,25 @@ public class prog8Parser extends Parser {
 			setState(757);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
-			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__25) | (1L << T__40) | (1L << T__41) | (1L << T__42) | (1L << T__62))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__66 - 64)) | (1L << (T__71 - 64)) | (1L << (T__72 - 64)) | (1L << (T__73 - 64)) | (1L << (T__82 - 64)) | (1L << (T__83 - 64)) | (1L << (T__91 - 64)) | (1L << (EOL - 64)) | (1L << (NAME - 64)) | (1L << (DEC_INTEGER - 64)) | (1L << (HEX_INTEGER - 64)) | (1L << (BIN_INTEGER - 64)) | (1L << (ADDRESS_OF - 64)) | (1L << (FLOAT_NUMBER - 64)) | (1L << (STRING - 64)) | (1L << (SINGLECHAR - 64)))) != 0)) {
+			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__16) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__41) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (T__90 - 66)) | (1L << (EOL - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (ADDRESS_OF - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) {
 				{
 				setState(755);
 				_errHandler.sync(this);
 				switch (_input.LA(1)) {
 				case T__16:
-				case T__25:
+				case T__24:
+				case T__39:
 				case T__40:
 				case T__41:
-				case T__42:
+				case T__61:
 				case T__62:
-				case T__63:
-				case T__66:
+				case T__65:
+				case T__70:
 				case T__71:
 				case T__72:
-				case T__73:
+				case T__81:
 				case T__82:
-				case T__83:
-				case T__91:
+				case T__90:
 				case NAME:
 				case DEC_INTEGER:
 				case HEX_INTEGER:
@@ -5086,18 +5079,18 @@ public class prog8Parser extends Parser {
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__16:
-			case T__25:
+			case T__24:
+			case T__39:
 			case T__40:
 			case T__41:
-			case T__42:
+			case T__61:
 			case T__62:
-			case T__63:
-			case T__66:
+			case T__65:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__81:
 			case T__82:
-			case T__83:
 			case NAME:
 			case DEC_INTEGER:
 			case HEX_INTEGER:
@@ -5111,17 +5104,17 @@ public class prog8Parser extends Parser {
 				expression_list();
 				}
 				break;
-			case T__91:
+			case T__90:
 				{
 				setState(765);
-				match(T__91);
+				match(T__90);
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
 			setState(768);
-			match(T__86);
+			match(T__85);
 			setState(771);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
@@ -5144,18 +5137,18 @@ public class prog8Parser extends Parser {
 			case T__21:
 			case T__22:
 			case T__23:
-			case T__24:
+			case T__65:
 			case T__66:
 			case T__67:
 			case T__68:
-			case T__69:
+			case T__70:
 			case T__71:
 			case T__72:
-			case T__73:
+			case T__83:
 			case T__84:
-			case T__85:
-			case T__87:
-			case T__90:
+			case T__86:
+			case T__89:
+			case T__91:
 			case T__92:
 			case T__93:
 			case T__94:
@@ -5168,10 +5161,9 @@ public class prog8Parser extends Parser {
 			case T__101:
 			case T__102:
 			case T__103:
-			case T__104:
+			case T__105:
 			case T__106:
-			case T__107:
-			case T__109:
+			case T__108:
 			case NAME:
 			case ADDRESS_OF:
 				{
@@ -5243,9 +5235,9 @@ public class prog8Parser extends Parser {
 	}
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3\177\u0308\4\2\t\2"+
-		"\4\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13"+
-		"\t\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3~\u0308\4\2\t\2\4"+
+		"\3\t\3\4\4\t\4\4\5\t\5\4\6\t\6\4\7\t\7\4\b\t\b\4\t\t\t\4\n\t\n\4\13\t"+
+		"\13\4\f\t\f\4\r\t\r\4\16\t\16\4\17\t\17\4\20\t\20\4\21\t\21\4\22\t\22"+
 		"\4\23\t\23\4\24\t\24\4\25\t\25\4\26\t\26\4\27\t\27\4\30\t\30\4\31\t\31"+
 		"\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
 		"\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
@@ -5301,8 +5293,8 @@ public class prog8Parser extends Parser {
 		"\u02f6\nE\fE\16E\u02f9\13E\3E\3E\5E\u02fd\nE\3F\3F\5F\u0301\nF\3F\3F\3"+
 		"F\5F\u0306\nF\3F\2\3,G\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,"+
 		".\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\u0080\u0082\u0084\u0086"+
-		"\u0088\u008a\2\22\3\2\5\16\3\2\25\33\3\2\36(\3\2)*\3\2+-\3\2/\61\3\2+"+
-		",\3\2\62\63\3\2\64\67\3\289\3\2JL\3\2JO\3\2PS\3\2vx\3\2UV\3\2_j\2\u035f"+
+		"\u0088\u008a\2\22\3\2\5\16\3\2\25\32\3\2\35\'\3\2()\3\2*,\3\2.\60\3\2"+
+		"*+\3\2\61\62\3\2\63\66\3\2\678\3\2IK\3\2IN\3\2OR\3\2uw\3\2TU\3\2^i\2\u035f"+
 		"\2\u0090\3\2\2\2\4\u0097\3\2\2\2\6\u0099\3\2\2\2\b\u00ba\3\2\2\2\n\u00bc"+
 		"\3\2\2\2\f\u00bf\3\2\2\2\16\u00c4\3\2\2\2\20\u00d5\3\2\2\2\22\u00d7\3"+
 		"\2\2\2\24\u00e1\3\2\2\2\26\u00e4\3\2\2\2\30\u00e8\3\2\2\2\32\u00ec\3\2"+
@@ -5319,12 +5311,12 @@ public class prog8Parser extends Parser {
 		"\3\2\2\2x\u029d\3\2\2\2z\u02a4\3\2\2\2|\u02b3\3\2\2\2~\u02bb\3\2\2\2\u0080"+
 		"\u02cb\3\2\2\2\u0082\u02cd\3\2\2\2\u0084\u02db\3\2\2\2\u0086\u02e4\3\2"+
 		"\2\2\u0088\u02ef\3\2\2\2\u008a\u0300\3\2\2\2\u008c\u008f\5\4\3\2\u008d"+
-		"\u008f\7t\2\2\u008e\u008c\3\2\2\2\u008e\u008d\3\2\2\2\u008f\u0092\3\2"+
+		"\u008f\7s\2\2\u008e\u008c\3\2\2\2\u008e\u008d\3\2\2\2\u008f\u0092\3\2"+
 		"\2\2\u0090\u008e\3\2\2\2\u0090\u0091\3\2\2\2\u0091\u0093\3\2\2\2\u0092"+
 		"\u0090\3\2\2\2\u0093\u0094\7\2\2\3\u0094\3\3\2\2\2\u0095\u0098\5\16\b"+
 		"\2\u0096\u0098\5\6\4\2\u0097\u0095\3\2\2\2\u0097\u0096\3\2\2\2\u0098\5"+
 		"\3\2\2\2\u0099\u009b\5B\"\2\u009a\u009c\5L\'\2\u009b\u009a\3\2\2\2\u009b"+
-		"\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e\5d\63\2\u009e\u009f\7t"+
+		"\u009c\3\2\2\2\u009c\u009d\3\2\2\2\u009d\u009e\5d\63\2\u009e\u009f\7s"+
 		"\2\2\u009f\7\3\2\2\2\u00a0\u00bb\5\16\b\2\u00a1\u00bb\5\26\f\2\u00a2\u00bb"+
 		"\5\30\r\2\u00a3\u00bb\5\22\n\2\u00a4\u00bb\5\24\13\2\u00a5\u00bb\5\32"+
 		"\16\2\u00a6\u00bb\5\34\17\2\u00a7\u00bb\5\36\20\2\u00a8\u00bb\5$\23\2"+
@@ -5350,192 +5342,192 @@ public class prog8Parser extends Parser {
 		"\3\2\2\2\u00d0\u00c8\3\2\2\2\u00d1\17\3\2\2\2\u00d2\u00d6\5V,\2\u00d3"+
 		"\u00d6\5B\"\2\u00d4\u00d6\5L\'\2\u00d5\u00d2\3\2\2\2\u00d5\u00d3\3\2\2"+
 		"\2\u00d5\u00d4\3\2\2\2\u00d6\21\3\2\2\2\u00d7\u00d9\5 \21\2\u00d8\u00da"+
-		"\7~\2\2\u00d9\u00d8\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00dd\3\2\2\2\u00db"+
-		"\u00de\5\"\22\2\u00dc\u00de\7\177\2\2\u00dd\u00db\3\2\2\2\u00dd\u00dc"+
-		"\3\2\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\5B\"\2\u00e0"+
+		"\7}\2\2\u00d9\u00d8\3\2\2\2\u00d9\u00da\3\2\2\2\u00da\u00dd\3\2\2\2\u00db"+
+		"\u00de\5\"\22\2\u00dc\u00de\7~\2\2\u00dd\u00db\3\2\2\2\u00dd\u00dc\3\2"+
+		"\2\2\u00dd\u00de\3\2\2\2\u00de\u00df\3\2\2\2\u00df\u00e0\5B\"\2\u00e0"+
 		"\23\3\2\2\2\u00e1\u00e2\5B\"\2\u00e2\u00e3\5B\"\2\u00e3\25\3\2\2\2\u00e4"+
 		"\u00e5\5\22\n\2\u00e5\u00e6\7\20\2\2\u00e6\u00e7\5,\27\2\u00e7\27\3\2"+
 		"\2\2\u00e8\u00e9\5\24\13\2\u00e9\u00ea\7\20\2\2\u00ea\u00eb\5,\27\2\u00eb"+
 		"\31\3\2\2\2\u00ec\u00ed\7\21\2\2\u00ed\u00ee\5\26\f\2\u00ee\33\3\2\2\2"+
-		"\u00ef\u00f0\7y\2\2\u00f0\u00f1\5\26\f\2\u00f1\35\3\2\2\2\u00f2\u00f3"+
-		"\7\22\2\2\u00f3\u00f4\5B\"\2\u00f4\u00f5\7\23\2\2\u00f5\u00f6\7t\2\2\u00f6"+
-		"\u00fb\5\22\n\2\u00f7\u00f8\7t\2\2\u00f8\u00fa\5\22\n\2\u00f9\u00f7\3"+
+		"\u00ef\u00f0\7x\2\2\u00f0\u00f1\5\26\f\2\u00f1\35\3\2\2\2\u00f2\u00f3"+
+		"\7\22\2\2\u00f3\u00f4\5B\"\2\u00f4\u00f5\7\23\2\2\u00f5\u00f6\7s\2\2\u00f6"+
+		"\u00fb\5\22\n\2\u00f7\u00f8\7s\2\2\u00f8\u00fa\5\22\n\2\u00f9\u00f7\3"+
 		"\2\2\2\u00fa\u00fd\3\2\2\2\u00fb\u00f9\3\2\2\2\u00fb\u00fc\3\2\2\2\u00fc"+
-		"\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fe\u0100\7t\2\2\u00ff\u00fe\3\2"+
+		"\u00ff\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fe\u0100\7s\2\2\u00ff\u00fe\3\2"+
 		"\2\2\u00ff\u0100\3\2\2\2\u0100\u0101\3\2\2\2\u0101\u0102\7\24\2\2\u0102"+
-		"\u0103\7t\2\2\u0103\37\3\2\2\2\u0104\u0105\t\3\2\2\u0105!\3\2\2\2\u0106"+
-		"\u0107\7\34\2\2\u0107\u0108\5,\27\2\u0108\u0109\7\35\2\2\u0109#\3\2\2"+
+		"\u0103\7s\2\2\u0103\37\3\2\2\2\u0104\u0105\t\3\2\2\u0105!\3\2\2\2\u0106"+
+		"\u0107\7\33\2\2\u0107\u0108\5,\27\2\u0108\u0109\7\34\2\2\u0109#\3\2\2"+
 		"\2\u010a\u010b\5(\25\2\u010b\u010c\7\20\2\2\u010c\u010d\5,\27\2\u010d"+
 		"%\3\2\2\2\u010e\u010f\5(\25\2\u010f\u0110\t\4\2\2\u0110\u0111\5,\27\2"+
 		"\u0111\'\3\2\2\2\u0112\u0117\5F$\2\u0113\u0117\5D#\2\u0114\u0117\5\60"+
 		"\31\2\u0115\u0117\5\62\32\2\u0116\u0112\3\2\2\2\u0116\u0113\3\2\2\2\u0116"+
 		"\u0114\3\2\2\2\u0116\u0115\3\2\2\2\u0117)\3\2\2\2\u0118\u0119\5(\25\2"+
 		"\u0119\u011a\t\5\2\2\u011a+\3\2\2\2\u011b\u011c\b\27\1\2\u011c\u012c\5"+
-		"\66\34\2\u011d\u011e\t\6\2\2\u011e\u012c\5,\27\31\u011f\u0120\7A\2\2\u0120"+
+		"\66\34\2\u011d\u011e\t\6\2\2\u011e\u012c\5,\27\31\u011f\u0120\7@\2\2\u0120"+
 		"\u012c\5,\27\13\u0121\u012c\5\\/\2\u0122\u012c\5F$\2\u0123\u012c\5D#\2"+
 		"\u0124\u012c\5\60\31\2\u0125\u012c\5\62\32\2\u0126\u012c\5\64\33\2\u0127"+
-		"\u0128\7B\2\2\u0128\u0129\5,\27\2\u0129\u012a\7C\2\2\u012a\u012c\3\2\2"+
+		"\u0128\7A\2\2\u0128\u0129\5,\27\2\u0129\u012a\7B\2\2\u012a\u012c\3\2\2"+
 		"\2\u012b\u011b\3\2\2\2\u012b\u011d\3\2\2\2\u012b\u011f\3\2\2\2\u012b\u0121"+
 		"\3\2\2\2\u012b\u0122\3\2\2\2\u012b\u0123\3\2\2\2\u012b\u0124\3\2\2\2\u012b"+
 		"\u0125\3\2\2\2\u012b\u0126\3\2\2\2\u012b\u0127\3\2\2\2\u012c\u01a4\3\2"+
-		"\2\2\u012d\u012f\f\30\2\2\u012e\u0130\7t\2\2\u012f\u012e\3\2\2\2\u012f"+
-		"\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\7.\2\2\u0132\u0134\7t\2"+
+		"\2\2\u012d\u012f\f\30\2\2\u012e\u0130\7s\2\2\u012f\u012e\3\2\2\2\u012f"+
+		"\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\7-\2\2\u0132\u0134\7s\2"+
 		"\2\u0133\u0132\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0135\3\2\2\2\u0135\u01a3"+
-		"\5,\27\31\u0136\u0138\f\27\2\2\u0137\u0139\7t\2\2\u0138\u0137\3\2\2\2"+
+		"\5,\27\31\u0136\u0138\f\27\2\2\u0137\u0139\7s\2\2\u0138\u0137\3\2\2\2"+
 		"\u0138\u0139\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013c\t\7\2\2\u013b\u013d"+
-		"\7t\2\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013e\3\2\2\2\u013e"+
-		"\u01a3\5,\27\30\u013f\u0141\f\26\2\2\u0140\u0142\7t\2\2\u0141\u0140\3"+
+		"\7s\2\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2\2\2\u013d\u013e\3\2\2\2\u013e"+
+		"\u01a3\5,\27\30\u013f\u0141\f\26\2\2\u0140\u0142\7s\2\2\u0141\u0140\3"+
 		"\2\2\2\u0141\u0142\3\2\2\2\u0142\u0143\3\2\2\2\u0143\u0145\t\b\2\2\u0144"+
-		"\u0146\7t\2\2\u0145\u0144\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0147\3\2"+
-		"\2\2\u0147\u01a3\5,\27\27\u0148\u014a\f\25\2\2\u0149\u014b\7t\2\2\u014a"+
+		"\u0146\7s\2\2\u0145\u0144\3\2\2\2\u0145\u0146\3\2\2\2\u0146\u0147\3\2"+
+		"\2\2\u0147\u01a3\5,\27\27\u0148\u014a\f\25\2\2\u0149\u014b\7s\2\2\u014a"+
 		"\u0149\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u014c\3\2\2\2\u014c\u014e\t\t"+
-		"\2\2\u014d\u014f\7t\2\2\u014e\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f"+
+		"\2\2\u014d\u014f\7s\2\2\u014e\u014d\3\2\2\2\u014e\u014f\3\2\2\2\u014f"+
 		"\u0150\3\2\2\2\u0150\u01a3\5,\27\26\u0151\u0153\f\24\2\2\u0152\u0154\7"+
-		"t\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0155\3\2\2\2\u0155"+
-		"\u0157\t\n\2\2\u0156\u0158\7t\2\2\u0157\u0156\3\2\2\2\u0157\u0158\3\2"+
+		"s\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2\u0154\u0155\3\2\2\2\u0155"+
+		"\u0157\t\n\2\2\u0156\u0158\7s\2\2\u0157\u0156\3\2\2\2\u0157\u0158\3\2"+
 		"\2\2\u0158\u0159\3\2\2\2\u0159\u01a3\5,\27\25\u015a\u015c\f\23\2\2\u015b"+
-		"\u015d\7t\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\3\2"+
-		"\2\2\u015e\u0160\t\13\2\2\u015f\u0161\7t\2\2\u0160\u015f\3\2\2\2\u0160"+
+		"\u015d\7s\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2\2\2\u015d\u015e\3\2"+
+		"\2\2\u015e\u0160\t\13\2\2\u015f\u0161\7s\2\2\u0160\u015f\3\2\2\2\u0160"+
 		"\u0161\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u01a3\5,\27\24\u0163\u0165\f"+
-		"\22\2\2\u0164\u0166\7t\2\2\u0165\u0164\3\2\2\2\u0165\u0166\3\2\2\2\u0166"+
-		"\u0167\3\2\2\2\u0167\u0169\7y\2\2\u0168\u016a\7t\2\2\u0169\u0168\3\2\2"+
+		"\22\2\2\u0164\u0166\7s\2\2\u0165\u0164\3\2\2\2\u0165\u0166\3\2\2\2\u0166"+
+		"\u0167\3\2\2\2\u0167\u0169\7x\2\2\u0168\u016a\7s\2\2\u0169\u0168\3\2\2"+
 		"\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u01a3\5,\27\23\u016c"+
-		"\u016e\f\21\2\2\u016d\u016f\7t\2\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2"+
-		"\2\2\u016f\u0170\3\2\2\2\u0170\u0172\7:\2\2\u0171\u0173\7t\2\2\u0172\u0171"+
+		"\u016e\f\21\2\2\u016d\u016f\7s\2\2\u016e\u016d\3\2\2\2\u016e\u016f\3\2"+
+		"\2\2\u016f\u0170\3\2\2\2\u0170\u0172\79\2\2\u0171\u0173\7s\2\2\u0172\u0171"+
 		"\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u01a3\5,\27\22"+
-		"\u0175\u0177\f\20\2\2\u0176\u0178\7t\2\2\u0177\u0176\3\2\2\2\u0177\u0178"+
-		"\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\7;\2\2\u017a\u017c\7t\2\2\u017b"+
+		"\u0175\u0177\f\20\2\2\u0176\u0178\7s\2\2\u0177\u0176\3\2\2\2\u0177\u0178"+
+		"\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\7:\2\2\u017a\u017c\7s\2\2\u017b"+
 		"\u017a\3\2\2\2\u017b\u017c\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u01a3\5,"+
-		"\27\21\u017e\u0180\f\16\2\2\u017f\u0181\7t\2\2\u0180\u017f\3\2\2\2\u0180"+
-		"\u0181\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0184\7>\2\2\u0183\u0185\7t\2"+
+		"\27\21\u017e\u0180\f\16\2\2\u017f\u0181\7s\2\2\u0180\u017f\3\2\2\2\u0180"+
+		"\u0181\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0184\7=\2\2\u0183\u0185\7s\2"+
 		"\2\u0184\u0183\3\2\2\2\u0184\u0185\3\2\2\2\u0185\u0186\3\2\2\2\u0186\u01a3"+
-		"\5,\27\17\u0187\u0189\f\r\2\2\u0188\u018a\7t\2\2\u0189\u0188\3\2\2\2\u0189"+
-		"\u018a\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\7?\2\2\u018c\u018e\7t\2"+
+		"\5,\27\17\u0187\u0189\f\r\2\2\u0188\u018a\7s\2\2\u0189\u0188\3\2\2\2\u0189"+
+		"\u018a\3\2\2\2\u018a\u018b\3\2\2\2\u018b\u018d\7>\2\2\u018c\u018e\7s\2"+
 		"\2\u018d\u018c\3\2\2\2\u018d\u018e\3\2\2\2\u018e\u018f\3\2\2\2\u018f\u01a3"+
-		"\5,\27\16\u0190\u0192\f\f\2\2\u0191\u0193\7t\2\2\u0192\u0191\3\2\2\2\u0192"+
-		"\u0193\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0196\7@\2\2\u0195\u0197\7t\2"+
+		"\5,\27\16\u0190\u0192\f\f\2\2\u0191\u0193\7s\2\2\u0192\u0191\3\2\2\2\u0192"+
+		"\u0193\3\2\2\2\u0193\u0194\3\2\2\2\u0194\u0196\7?\2\2\u0195\u0197\7s\2"+
 		"\2\u0196\u0195\3\2\2\2\u0196\u0197\3\2\2\2\u0197\u0198\3\2\2\2\u0198\u01a3"+
-		"\5,\27\r\u0199\u019a\f\17\2\2\u019a\u019b\7<\2\2\u019b\u019e\5,\27\2\u019c"+
-		"\u019d\7=\2\2\u019d\u019f\5,\27\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2"+
+		"\5,\27\r\u0199\u019a\f\17\2\2\u019a\u019b\7;\2\2\u019b\u019e\5,\27\2\u019c"+
+		"\u019d\7<\2\2\u019d\u019f\5,\27\2\u019e\u019c\3\2\2\2\u019e\u019f\3\2"+
 		"\2\2\u019f\u01a3\3\2\2\2\u01a0\u01a1\f\4\2\2\u01a1\u01a3\5.\30\2\u01a2"+
 		"\u012d\3\2\2\2\u01a2\u0136\3\2\2\2\u01a2\u013f\3\2\2\2\u01a2\u0148\3\2"+
 		"\2\2\u01a2\u0151\3\2\2\2\u01a2\u015a\3\2\2\2\u01a2\u0163\3\2\2\2\u01a2"+
 		"\u016c\3\2\2\2\u01a2\u0175\3\2\2\2\u01a2\u017e\3\2\2\2\u01a2\u0187\3\2"+
 		"\2\2\u01a2\u0190\3\2\2\2\u01a2\u0199\3\2\2\2\u01a2\u01a0\3\2\2\2\u01a3"+
 		"\u01a6\3\2\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5-\3\2\2\2"+
-		"\u01a6\u01a4\3\2\2\2\u01a7\u01a8\7D\2\2\u01a8\u01a9\5 \21\2\u01a9/\3\2"+
+		"\u01a6\u01a4\3\2\2\2\u01a7\u01a8\7C\2\2\u01a8\u01a9\5 \21\2\u01a9/\3\2"+
 		"\2\2\u01aa\u01ab\5D#\2\u01ab\u01ac\5\"\22\2\u01ac\61\3\2\2\2\u01ad\u01ae"+
-		"\7E\2\2\u01ae\u01af\7B\2\2\u01af\u01b0\5,\27\2\u01b0\u01b1\7C\2\2\u01b1"+
-		"\63\3\2\2\2\u01b2\u01b3\7y\2\2\u01b3\u01b4\5D#\2\u01b4\65\3\2\2\2\u01b5"+
-		"\u01b6\5D#\2\u01b6\u01b8\7B\2\2\u01b7\u01b9\5:\36\2\u01b8\u01b7\3\2\2"+
-		"\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb\7C\2\2\u01bb\67"+
-		"\3\2\2\2\u01bc\u01bd\5D#\2\u01bd\u01bf\7B\2\2\u01be\u01c0\5:\36\2\u01bf"+
-		"\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c2\7C"+
+		"\7D\2\2\u01ae\u01af\7A\2\2\u01af\u01b0\5,\27\2\u01b0\u01b1\7B\2\2\u01b1"+
+		"\63\3\2\2\2\u01b2\u01b3\7x\2\2\u01b3\u01b4\5D#\2\u01b4\65\3\2\2\2\u01b5"+
+		"\u01b6\5D#\2\u01b6\u01b8\7A\2\2\u01b7\u01b9\5:\36\2\u01b8\u01b7\3\2\2"+
+		"\2\u01b8\u01b9\3\2\2\2\u01b9\u01ba\3\2\2\2\u01ba\u01bb\7B\2\2\u01bb\67"+
+		"\3\2\2\2\u01bc\u01bd\5D#\2\u01bd\u01bf\7A\2\2\u01be\u01c0\5:\36\2\u01bf"+
+		"\u01be\3\2\2\2\u01bf\u01c0\3\2\2\2\u01c0\u01c1\3\2\2\2\u01c1\u01c2\7B"+
 		"\2\2\u01c29\3\2\2\2\u01c3\u01cb\5,\27\2\u01c4\u01c6\7\17\2\2\u01c5\u01c7"+
-		"\7t\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8"+
+		"\7s\2\2\u01c6\u01c5\3\2\2\2\u01c6\u01c7\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8"+
 		"\u01ca\5,\27\2\u01c9\u01c4\3\2\2\2\u01ca\u01cd\3\2\2\2\u01cb\u01c9\3\2"+
 		"\2\2\u01cb\u01cc\3\2\2\2\u01cc;\3\2\2\2\u01cd\u01cb\3\2\2\2\u01ce\u01d0"+
-		"\7F\2\2\u01cf\u01d1\5,\27\2\u01d0\u01cf\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1"+
-		"=\3\2\2\2\u01d2\u01d3\7G\2\2\u01d3?\3\2\2\2\u01d4\u01d5\7H\2\2\u01d5A"+
-		"\3\2\2\2\u01d6\u01d7\7u\2\2\u01d7C\3\2\2\2\u01d8\u01dd\7u\2\2\u01d9\u01da"+
-		"\7I\2\2\u01da\u01dc\7u\2\2\u01db\u01d9\3\2\2\2\u01dc\u01df\3\2\2\2\u01dd"+
+		"\7E\2\2\u01cf\u01d1\5,\27\2\u01d0\u01cf\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1"+
+		"=\3\2\2\2\u01d2\u01d3\7F\2\2\u01d3?\3\2\2\2\u01d4\u01d5\7G\2\2\u01d5A"+
+		"\3\2\2\2\u01d6\u01d7\7t\2\2\u01d7C\3\2\2\2\u01d8\u01dd\7t\2\2\u01d9\u01da"+
+		"\7H\2\2\u01da\u01dc\7t\2\2\u01db\u01d9\3\2\2\2\u01dc\u01df\3\2\2\2\u01dd"+
 		"\u01db\3\2\2\2\u01dd\u01de\3\2\2\2\u01deE\3\2\2\2\u01df\u01dd\3\2\2\2"+
 		"\u01e0\u01e1\t\f\2\2\u01e1G\3\2\2\2\u01e2\u01e3\t\r\2\2\u01e3I\3\2\2\2"+
 		"\u01e4\u01e5\t\16\2\2\u01e5K\3\2\2\2\u01e6\u01e8\t\17\2\2\u01e7\u01e9"+
 		"\5N(\2\u01e8\u01e7\3\2\2\2\u01e8\u01e9\3\2\2\2\u01e9M\3\2\2\2\u01ea\u01eb"+
-		"\7T\2\2\u01ebO\3\2\2\2\u01ec\u01ed\t\20\2\2\u01edQ\3\2\2\2\u01ee\u01f0"+
-		"\7\34\2\2\u01ef\u01f1\7t\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1"+
+		"\7S\2\2\u01ebO\3\2\2\2\u01ec\u01ed\t\20\2\2\u01edQ\3\2\2\2\u01ee\u01f0"+
+		"\7\33\2\2\u01ef\u01f1\7s\2\2\u01f0\u01ef\3\2\2\2\u01f0\u01f1\3\2\2\2\u01f1"+
 		"\u01f2\3\2\2\2\u01f2\u01fa\5,\27\2\u01f3\u01f5\7\17\2\2\u01f4\u01f6\7"+
-		"t\2\2\u01f5\u01f4\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7"+
+		"s\2\2\u01f5\u01f4\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7\3\2\2\2\u01f7"+
 		"\u01f9\5,\27\2\u01f8\u01f3\3\2\2\2\u01f9\u01fc\3\2\2\2\u01fa\u01f8\3\2"+
 		"\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fe\3\2\2\2\u01fc\u01fa\3\2\2\2\u01fd"+
-		"\u01ff\7t\2\2\u01fe\u01fd\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\3\2"+
-		"\2\2\u0200\u0201\7\35\2\2\u0201S\3\2\2\2\u0202\u0204\7\23\2\2\u0203\u0205"+
-		"\7t\2\2\u0204\u0203\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0206\3\2\2\2\u0206"+
-		"\u020e\5,\27\2\u0207\u0209\7\17\2\2\u0208\u020a\7t\2\2\u0209\u0208\3\2"+
+		"\u01ff\7s\2\2\u01fe\u01fd\3\2\2\2\u01fe\u01ff\3\2\2\2\u01ff\u0200\3\2"+
+		"\2\2\u0200\u0201\7\34\2\2\u0201S\3\2\2\2\u0202\u0204\7\23\2\2\u0203\u0205"+
+		"\7s\2\2\u0204\u0203\3\2\2\2\u0204\u0205\3\2\2\2\u0205\u0206\3\2\2\2\u0206"+
+		"\u020e\5,\27\2\u0207\u0209\7\17\2\2\u0208\u020a\7s\2\2\u0209\u0208\3\2"+
 		"\2\2\u0209\u020a\3\2\2\2\u020a\u020b\3\2\2\2\u020b\u020d\5,\27\2\u020c"+
 		"\u0207\3\2\2\2\u020d\u0210\3\2\2\2\u020e\u020c\3\2\2\2\u020e\u020f\3\2"+
-		"\2\2\u020f\u0212\3\2\2\2\u0210\u020e\3\2\2\2\u0211\u0213\7t\2\2\u0212"+
+		"\2\2\u020f\u0212\3\2\2\2\u0210\u020e\3\2\2\2\u0211\u0213\7s\2\2\u0212"+
 		"\u0211\3\2\2\2\u0212\u0213\3\2\2\2\u0213\u0214\3\2\2\2\u0214\u0215\7\24"+
-		"\2\2\u0215U\3\2\2\2\u0216\u0217\7{\2\2\u0217W\3\2\2\2\u0218\u0219\7}\2"+
-		"\2\u0219Y\3\2\2\2\u021a\u021b\7z\2\2\u021b[\3\2\2\2\u021c\u0224\5L\'\2"+
+		"\2\2\u0215U\3\2\2\2\u0216\u0217\7z\2\2\u0217W\3\2\2\2\u0218\u0219\7|\2"+
+		"\2\u0219Y\3\2\2\2\u021a\u021b\7y\2\2\u021b[\3\2\2\2\u021c\u0224\5L\'\2"+
 		"\u021d\u0224\5P)\2\u021e\u0224\5R*\2\u021f\u0224\5V,\2\u0220\u0224\5X"+
 		"-\2\u0221\u0224\5Z.\2\u0222\u0224\5T+\2\u0223\u021c\3\2\2\2\u0223\u021d"+
 		"\3\2\2\2\u0223\u021e\3\2\2\2\u0223\u021f\3\2\2\2\u0223\u0220\3\2\2\2\u0223"+
-		"\u0221\3\2\2\2\u0223\u0222\3\2\2\2\u0224]\3\2\2\2\u0225\u0226\7W\2\2\u0226"+
-		"\u0227\7|\2\2\u0227_\3\2\2\2\u0228\u0229\7X\2\2\u0229\u022a\5B\"\2\u022a"+
-		"\u022c\7B\2\2\u022b\u022d\5f\64\2\u022c\u022b\3\2\2\2\u022c\u022d\3\2"+
-		"\2\2\u022d\u022e\3\2\2\2\u022e\u0230\7C\2\2\u022f\u0231\5b\62\2\u0230"+
+		"\u0221\3\2\2\2\u0223\u0222\3\2\2\2\u0224]\3\2\2\2\u0225\u0226\7V\2\2\u0226"+
+		"\u0227\7{\2\2\u0227_\3\2\2\2\u0228\u0229\7W\2\2\u0229\u022a\5B\"\2\u022a"+
+		"\u022c\7A\2\2\u022b\u022d\5f\64\2\u022c\u022b\3\2\2\2\u022c\u022d\3\2"+
+		"\2\2\u022d\u022e\3\2\2\2\u022e\u0230\7B\2\2\u022f\u0231\5b\62\2\u0230"+
 		"\u022f\3\2\2\2\u0230\u0231\3\2\2\2\u0231\u0232\3\2\2\2\u0232\u0233\5d"+
-		"\63\2\u0233\u0234\7t\2\2\u0234a\3\2\2\2\u0235\u0236\7Y\2\2\u0236\u0237"+
-		"\5h\65\2\u0237c\3\2\2\2\u0238\u0239\7\23\2\2\u0239\u023e\7t\2\2\u023a"+
-		"\u023d\5\b\5\2\u023b\u023d\7t\2\2\u023c\u023a\3\2\2\2\u023c\u023b\3\2"+
+		"\63\2\u0233\u0234\7s\2\2\u0234a\3\2\2\2\u0235\u0236\7X\2\2\u0236\u0237"+
+		"\5h\65\2\u0237c\3\2\2\2\u0238\u0239\7\23\2\2\u0239\u023e\7s\2\2\u023a"+
+		"\u023d\5\b\5\2\u023b\u023d\7s\2\2\u023c\u023a\3\2\2\2\u023c\u023b\3\2"+
 		"\2\2\u023d\u0240\3\2\2\2\u023e\u023c\3\2\2\2\u023e\u023f\3\2\2\2\u023f"+
 		"\u0241\3\2\2\2\u0240\u023e\3\2\2\2\u0241\u0242\7\24\2\2\u0242e\3\2\2\2"+
-		"\u0243\u024b\5\22\n\2\u0244\u0246\7\17\2\2\u0245\u0247\7t\2\2\u0246\u0245"+
+		"\u0243\u024b\5\22\n\2\u0244\u0246\7\17\2\2\u0245\u0247\7s\2\2\u0246\u0245"+
 		"\3\2\2\2\u0246\u0247\3\2\2\2\u0247\u0248\3\2\2\2\u0248\u024a\5\22\n\2"+
 		"\u0249\u0244\3\2\2\2\u024a\u024d\3\2\2\2\u024b\u0249\3\2\2\2\u024b\u024c"+
 		"\3\2\2\2\u024cg\3\2\2\2\u024d\u024b\3\2\2\2\u024e\u0256\5 \21\2\u024f"+
-		"\u0251\7\17\2\2\u0250\u0252\7t\2\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2"+
+		"\u0251\7\17\2\2\u0250\u0252\7s\2\2\u0251\u0250\3\2\2\2\u0251\u0252\3\2"+
 		"\2\2\u0252\u0253\3\2\2\2\u0253\u0255\5 \21\2\u0254\u024f\3\2\2\2\u0255"+
 		"\u0258\3\2\2\2\u0256\u0254\3\2\2\2\u0256\u0257\3\2\2\2\u0257i\3\2\2\2"+
-		"\u0258\u0256\3\2\2\2\u0259\u025a\7Z\2\2\u025a\u025b\5B\"\2\u025b\u025d"+
-		"\7B\2\2\u025c\u025e\5n8\2\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025e"+
-		"\u025f\3\2\2\2\u025f\u0261\7C\2\2\u0260\u0262\7t\2\2\u0261\u0260\3\2\2"+
+		"\u0258\u0256\3\2\2\2\u0259\u025a\7Y\2\2\u025a\u025b\5B\"\2\u025b\u025d"+
+		"\7A\2\2\u025c\u025e\5n8\2\u025d\u025c\3\2\2\2\u025d\u025e\3\2\2\2\u025e"+
+		"\u025f\3\2\2\2\u025f\u0261\7B\2\2\u0260\u0262\7s\2\2\u0261\u0260\3\2\2"+
 		"\2\u0261\u0262\3\2\2\2\u0262\u0264\3\2\2\2\u0263\u0265\5r:\2\u0264\u0263"+
 		"\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0267\3\2\2\2\u0266\u0268\5v<\2\u0267"+
 		"\u0266\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u026b\3\2\2\2\u0269\u026c\5l"+
 		"\67\2\u026a\u026c\5d\63\2\u026b\u0269\3\2\2\2\u026b\u026a\3\2\2\2\u026c"+
 		"k\3\2\2\2\u026d\u026e\7\20\2\2\u026e\u026f\5L\'\2\u026fm\3\2\2\2\u0270"+
-		"\u0278\5p9\2\u0271\u0273\7\17\2\2\u0272\u0274\7t\2\2\u0273\u0272\3\2\2"+
+		"\u0278\5p9\2\u0271\u0273\7\17\2\2\u0272\u0274\7s\2\2\u0273\u0272\3\2\2"+
 		"\2\u0273\u0274\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0277\5p9\2\u0276\u0271"+
 		"\3\2\2\2\u0277\u027a\3\2\2\2\u0278\u0276\3\2\2\2\u0278\u0279\3\2\2\2\u0279"+
-		"o\3\2\2\2\u027a\u0278\3\2\2\2\u027b\u027c\5\22\n\2\u027c\u0280\7E\2\2"+
-		"\u027d\u0281\5H%\2\u027e\u0281\5J&\2\u027f\u0281\7[\2\2\u0280\u027d\3"+
+		"o\3\2\2\2\u027a\u0278\3\2\2\2\u027b\u027c\5\22\n\2\u027c\u0280\7D\2\2"+
+		"\u027d\u0281\5H%\2\u027e\u0281\5J&\2\u027f\u0281\7Z\2\2\u0280\u027d\3"+
 		"\2\2\2\u0280\u027e\3\2\2\2\u0280\u027f\3\2\2\2\u0281q\3\2\2\2\u0282\u0283"+
-		"\7\\\2\2\u0283\u0285\7B\2\2\u0284\u0286\5t;\2\u0285\u0284\3\2\2\2\u0285"+
-		"\u0286\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7C\2\2\u0288s\3\2\2\2\u0289"+
+		"\7[\2\2\u0283\u0285\7A\2\2\u0284\u0286\5t;\2\u0285\u0284\3\2\2\2\u0285"+
+		"\u0286\3\2\2\2\u0286\u0287\3\2\2\2\u0287\u0288\7B\2\2\u0288s\3\2\2\2\u0289"+
 		"\u028e\5F$\2\u028a\u028b\7\17\2\2\u028b\u028d\5F$\2\u028c\u028a\3\2\2"+
 		"\2\u028d\u0290\3\2\2\2\u028e\u028c\3\2\2\2\u028e\u028f\3\2\2\2\u028fu"+
-		"\3\2\2\2\u0290\u028e\3\2\2\2\u0291\u0292\7Y\2\2\u0292\u029a\5x=\2\u0293"+
-		"\u0295\7\17\2\2\u0294\u0296\7t\2\2\u0295\u0294\3\2\2\2\u0295\u0296\3\2"+
+		"\3\2\2\2\u0290\u028e\3\2\2\2\u0291\u0292\7X\2\2\u0292\u029a\5x=\2\u0293"+
+		"\u0295\7\17\2\2\u0294\u0296\7s\2\2\u0295\u0294\3\2\2\2\u0295\u0296\3\2"+
 		"\2\2\u0296\u0297\3\2\2\2\u0297\u0299\5x=\2\u0298\u0293\3\2\2\2\u0299\u029c"+
 		"\3\2\2\2\u029a\u0298\3\2\2\2\u029a\u029b\3\2\2\2\u029bw\3\2\2\2\u029c"+
-		"\u029a\3\2\2\2\u029d\u029e\5 \21\2\u029e\u02a2\7E\2\2\u029f\u02a3\5H%"+
-		"\2\u02a0\u02a3\5J&\2\u02a1\u02a3\7[\2\2\u02a2\u029f\3\2\2\2\u02a2\u02a0"+
-		"\3\2\2\2\u02a2\u02a1\3\2\2\2\u02a3y\3\2\2\2\u02a4\u02a5\7]\2\2\u02a5\u02a7"+
-		"\5,\27\2\u02a6\u02a8\7t\2\2\u02a7\u02a6\3\2\2\2\u02a7\u02a8\3\2\2\2\u02a8"+
-		"\u02ab\3\2\2\2\u02a9\u02ac\5\b\5\2\u02aa\u02ac\5d\63\2\u02ab\u02a9\3\2"+
-		"\2\2\u02ab\u02aa\3\2\2\2\u02ac\u02ae\3\2\2\2\u02ad\u02af\7t\2\2\u02ae"+
-		"\u02ad\3\2\2\2\u02ae\u02af\3\2\2\2\u02af\u02b1\3\2\2\2\u02b0\u02b2\5|"+
-		"?\2\u02b1\u02b0\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2{\3\2\2\2\u02b3\u02b5"+
-		"\7^\2\2\u02b4\u02b6\7t\2\2\u02b5\u02b4\3\2\2\2\u02b5\u02b6\3\2\2\2\u02b6"+
-		"\u02b9\3\2\2\2\u02b7\u02ba\5\b\5\2\u02b8\u02ba\5d\63\2\u02b9\u02b7\3\2"+
-		"\2\2\u02b9\u02b8\3\2\2\2\u02ba}\3\2\2\2\u02bb\u02bd\5\u0080A\2\u02bc\u02be"+
-		"\7t\2\2\u02bd\u02bc\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c1\3\2\2\2\u02bf"+
-		"\u02c2\5\b\5\2\u02c0\u02c2\5d\63\2\u02c1\u02bf\3\2\2\2\u02c1\u02c0\3\2"+
-		"\2\2\u02c2\u02c4\3\2\2\2\u02c3\u02c5\7t\2\2\u02c4\u02c3\3\2\2\2\u02c4"+
-		"\u02c5\3\2\2\2\u02c5\u02c7\3\2\2\2\u02c6\u02c8\5|?\2\u02c7\u02c6\3\2\2"+
-		"\2\u02c7\u02c8\3\2\2\2\u02c8\u02c9\3\2\2\2\u02c9\u02ca\7t\2\2\u02ca\177"+
-		"\3\2\2\2\u02cb\u02cc\t\21\2\2\u02cc\u0081\3\2\2\2\u02cd\u02d0\7k\2\2\u02ce"+
-		"\u02d1\5F$\2\u02cf\u02d1\5B\"\2\u02d0\u02ce\3\2\2\2\u02d0\u02cf\3\2\2"+
-		"\2\u02d1\u02d2\3\2\2\2\u02d2\u02d3\7l\2\2\u02d3\u02d5\5,\27\2\u02d4\u02d6"+
-		"\7t\2\2\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6\u02d9\3\2\2\2\u02d7"+
-		"\u02da\5\b\5\2\u02d8\u02da\5d\63\2\u02d9\u02d7\3\2\2\2\u02d9\u02d8\3\2"+
-		"\2\2\u02da\u0083\3\2\2\2\u02db\u02dc\7m\2\2\u02dc\u02de\5,\27\2\u02dd"+
-		"\u02df\7t\2\2\u02de\u02dd\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e2\3\2"+
-		"\2\2\u02e0\u02e3\5\b\5\2\u02e1\u02e3\5d\63\2\u02e2\u02e0\3\2\2\2\u02e2"+
-		"\u02e1\3\2\2\2\u02e3\u0085\3\2\2\2\u02e4\u02e7\7n\2\2\u02e5\u02e8\5\b"+
+		"\u029a\3\2\2\2\u029d\u029e\5 \21\2\u029e\u02a2\7D\2\2\u029f\u02a3\5H%"+
+		"\2\u02a0\u02a3\5J&\2\u02a1\u02a3\7Z\2\2\u02a2\u029f\3\2\2\2\u02a2\u02a0"+
+		"\3\2\2\2\u02a2\u02a1\3\2\2\2\u02a3y\3\2\2\2\u02a4\u02a5\7\\\2\2\u02a5"+
+		"\u02a7\5,\27\2\u02a6\u02a8\7s\2\2\u02a7\u02a6\3\2\2\2\u02a7\u02a8\3\2"+
+		"\2\2\u02a8\u02ab\3\2\2\2\u02a9\u02ac\5\b\5\2\u02aa\u02ac\5d\63\2\u02ab"+
+		"\u02a9\3\2\2\2\u02ab\u02aa\3\2\2\2\u02ac\u02ae\3\2\2\2\u02ad\u02af\7s"+
+		"\2\2\u02ae\u02ad\3\2\2\2\u02ae\u02af\3\2\2\2\u02af\u02b1\3\2\2\2\u02b0"+
+		"\u02b2\5|?\2\u02b1\u02b0\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2{\3\2\2\2\u02b3"+
+		"\u02b5\7]\2\2\u02b4\u02b6\7s\2\2\u02b5\u02b4\3\2\2\2\u02b5\u02b6\3\2\2"+
+		"\2\u02b6\u02b9\3\2\2\2\u02b7\u02ba\5\b\5\2\u02b8\u02ba\5d\63\2\u02b9\u02b7"+
+		"\3\2\2\2\u02b9\u02b8\3\2\2\2\u02ba}\3\2\2\2\u02bb\u02bd\5\u0080A\2\u02bc"+
+		"\u02be\7s\2\2\u02bd\u02bc\3\2\2\2\u02bd\u02be\3\2\2\2\u02be\u02c1\3\2"+
+		"\2\2\u02bf\u02c2\5\b\5\2\u02c0\u02c2\5d\63\2\u02c1\u02bf\3\2\2\2\u02c1"+
+		"\u02c0\3\2\2\2\u02c2\u02c4\3\2\2\2\u02c3\u02c5\7s\2\2\u02c4\u02c3\3\2"+
+		"\2\2\u02c4\u02c5\3\2\2\2\u02c5\u02c7\3\2\2\2\u02c6\u02c8\5|?\2\u02c7\u02c6"+
+		"\3\2\2\2\u02c7\u02c8\3\2\2\2\u02c8\u02c9\3\2\2\2\u02c9\u02ca\7s\2\2\u02ca"+
+		"\177\3\2\2\2\u02cb\u02cc\t\21\2\2\u02cc\u0081\3\2\2\2\u02cd\u02d0\7j\2"+
+		"\2\u02ce\u02d1\5F$\2\u02cf\u02d1\5B\"\2\u02d0\u02ce\3\2\2\2\u02d0\u02cf"+
+		"\3\2\2\2\u02d1\u02d2\3\2\2\2\u02d2\u02d3\7k\2\2\u02d3\u02d5\5,\27\2\u02d4"+
+		"\u02d6\7s\2\2\u02d5\u02d4\3\2\2\2\u02d5\u02d6\3\2\2\2\u02d6\u02d9\3\2"+
+		"\2\2\u02d7\u02da\5\b\5\2\u02d8\u02da\5d\63\2\u02d9\u02d7\3\2\2\2\u02d9"+
+		"\u02d8\3\2\2\2\u02da\u0083\3\2\2\2\u02db\u02dc\7l\2\2\u02dc\u02de\5,\27"+
+		"\2\u02dd\u02df\7s\2\2\u02de\u02dd\3\2\2\2\u02de\u02df\3\2\2\2\u02df\u02e2"+
+		"\3\2\2\2\u02e0\u02e3\5\b\5\2\u02e1\u02e3\5d\63\2\u02e2\u02e0\3\2\2\2\u02e2"+
+		"\u02e1\3\2\2\2\u02e3\u0085\3\2\2\2\u02e4\u02e7\7m\2\2\u02e5\u02e8\5\b"+
 		"\5\2\u02e6\u02e8\5d\63\2\u02e7\u02e5\3\2\2\2\u02e7\u02e6\3\2\2\2\u02e8"+
-		"\u02ea\3\2\2\2\u02e9\u02eb\7t\2\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2"+
-		"\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ed\7o\2\2\u02ed\u02ee\5,\27\2\u02ee"+
-		"\u0087\3\2\2\2\u02ef\u02f0\7p\2\2\u02f0\u02f1\5,\27\2\u02f1\u02f2\7\23"+
-		"\2\2\u02f2\u02f7\7t\2\2\u02f3\u02f6\5\u008aF\2\u02f4\u02f6\7t\2\2\u02f5"+
+		"\u02ea\3\2\2\2\u02e9\u02eb\7s\2\2\u02ea\u02e9\3\2\2\2\u02ea\u02eb\3\2"+
+		"\2\2\u02eb\u02ec\3\2\2\2\u02ec\u02ed\7n\2\2\u02ed\u02ee\5,\27\2\u02ee"+
+		"\u0087\3\2\2\2\u02ef\u02f0\7o\2\2\u02f0\u02f1\5,\27\2\u02f1\u02f2\7\23"+
+		"\2\2\u02f2\u02f7\7s\2\2\u02f3\u02f6\5\u008aF\2\u02f4\u02f6\7s\2\2\u02f5"+
 		"\u02f3\3\2\2\2\u02f5\u02f4\3\2\2\2\u02f6\u02f9\3\2\2\2\u02f7\u02f5\3\2"+
 		"\2\2\u02f7\u02f8\3\2\2\2\u02f8\u02fa\3\2\2\2\u02f9\u02f7\3\2\2\2\u02fa"+
-		"\u02fc\7\24\2\2\u02fb\u02fd\7t\2\2\u02fc\u02fb\3\2\2\2\u02fc\u02fd\3\2"+
-		"\2\2\u02fd\u0089\3\2\2\2\u02fe\u0301\5:\36\2\u02ff\u0301\7^\2\2\u0300"+
-		"\u02fe\3\2\2\2\u0300\u02ff\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0305\7Y"+
+		"\u02fc\7\24\2\2\u02fb\u02fd\7s\2\2\u02fc\u02fb\3\2\2\2\u02fc\u02fd\3\2"+
+		"\2\2\u02fd\u0089\3\2\2\2\u02fe\u0301\5:\36\2\u02ff\u0301\7]\2\2\u0300"+
+		"\u02fe\3\2\2\2\u0300\u02ff\3\2\2\2\u0301\u0302\3\2\2\2\u0302\u0305\7X"+
 		"\2\2\u0303\u0306\5\b\5\2\u0304\u0306\5d\63\2\u0305\u0303\3\2\2\2\u0305"+
 		"\u0304\3\2\2\2\u0306\u008b\3\2\2\2h\u008e\u0090\u0097\u009b\u00ba\u00c2"+
 		"\u00c6\u00cd\u00d0\u00d5\u00d9\u00dd\u00fb\u00ff\u0116\u012b\u012f\u0133"+