diff --git a/compiler/antlr/prog8.g4 b/compiler/antlr/prog8.g4
index 69b65deab..eee7d01ce 100644
--- a/compiler/antlr/prog8.g4
+++ b/compiler/antlr/prog8.g4
@@ -107,7 +107,9 @@ datatype:  'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_p' | 'st
 
 arrayspec:  '[' expression ']' ;
 
-assignment :  assign_target '=' expression ;
+assignment :  assign_targets '=' expression ;
+
+assign_targets : assign_target (',' assign_target)* ;
 
 augassignment :
 	assign_target operator=('+=' | '-=' | '/=' | '//=' | '*=' | '**=' | '&=' | '|=' | '^=') expression
diff --git a/compiler/examples/test.p8 b/compiler/examples/test.p8
index 50d3007ed..efaa51226 100644
--- a/compiler/examples/test.p8
+++ b/compiler/examples/test.p8
@@ -7,11 +7,13 @@
 
 sub start() {
 
-    ubyte derp
+    ubyte v1
+    ubyte v2
 
 
-    derp=foo()
-    derp=c64.GETADR()
+    v1=foo()
+    v1 , v2 =c64.GETADR()
+
     return
 }
 
diff --git a/compiler/src/prog8/ast/AST.kt b/compiler/src/prog8/ast/AST.kt
index badb63f7f..0687fc3c5 100644
--- a/compiler/src/prog8/ast/AST.kt
+++ b/compiler/src/prog8/ast/AST.kt
@@ -191,7 +191,7 @@ interface IAstProcessor {
     }
 
     fun process(assignment: Assignment): IStatement {
-        assignment.target = assignment.target.process(this)
+        assignment.targets = assignment.targets.map { it.process(this) }
         assignment.value = assignment.value.process(this)
         return assignment
     }
@@ -641,26 +641,31 @@ class VarDecl(val type: VarDeclType,
 }
 
 
-open class Assignment(var target: AssignTarget, val aug_op : String?, var value: IExpression, override val position: Position) : IStatement {
+open class Assignment(var targets: List<AssignTarget>, val aug_op : String?, var value: IExpression, override val position: Position) : IStatement {
     override lateinit var parent: Node
 
     override fun linkParents(parent: Node) {
         this.parent = parent
-        target.linkParents(this)
+        targets.forEach { it.linkParents(this) }
         value.linkParents(this)
     }
 
     override fun process(processor: IAstProcessor) = processor.process(this)
 
     override fun toString(): String {
-        return("Assignment(augop: $aug_op, target: $target, value: $value, pos=$position)")
+        return("Assignment(augop: $aug_op, targets: $targets, value: $value, pos=$position)")
     }
+
+    val singleTarget: AssignTarget?
+        get() {
+            return targets.singleOrNull()  // common case
+        }
 }
 
 // This is a special class so the compiler can see if the assignments are for initializing the vars in the scope,
 // or just a regular assignment. It may optimize the initialization step from this.
 class VariableInitializationAssignment(target: AssignTarget, aug_op: String?, value: IExpression, position: Position)
-    : Assignment(target, aug_op, value, position)
+    : Assignment(listOf(target), aug_op, value, position)
 
 
 data class AssignTarget(val register: Register?,
@@ -1645,11 +1650,11 @@ private fun prog8Parser.StatementContext.toAst() : IStatement {
     }
 
     assignment()?.let {
-        return Assignment(it.assign_target().toAst(),null, it.expression().toAst(), it.toPosition())
+        return Assignment(it.assign_targets().toAst(), null, it.expression().toAst(), it.toPosition())
     }
 
     augassignment()?.let {
-        return Assignment(it.assign_target().toAst(),
+        return Assignment(listOf(it.assign_target().toAst()),
                 it.operator.text,
                 it.expression().toAst(),
                 it.toPosition())
@@ -1707,6 +1712,8 @@ private fun prog8Parser.StatementContext.toAst() : IStatement {
     throw FatalAstException("unprocessed source text (are we missing ast conversion rules for parser elements?): $text")
 }
 
+private fun prog8Parser.Assign_targetsContext.toAst(): List<AssignTarget> = assign_target().map { it.toAst() }
+
 
 private fun prog8Parser.AsmsubroutineContext.toAst(): IStatement {
     val name = identifier().text
diff --git a/compiler/src/prog8/ast/AstChecker.kt b/compiler/src/prog8/ast/AstChecker.kt
index 0b5eb17f2..815b3e242 100644
--- a/compiler/src/prog8/ast/AstChecker.kt
+++ b/compiler/src/prog8/ast/AstChecker.kt
@@ -303,22 +303,31 @@ class AstChecker(private val namespace: INameScope,
      * Also check data type compatibility
      */
     override fun process(assignment: Assignment): IStatement {
-        if(assignment.target.identifier!=null) {
-            val targetName = assignment.target.identifier!!.nameInSource
+        var resultingAssignment = assignment
+        for (target in assignment.targets) {
+            resultingAssignment = processAssignmentTarget(resultingAssignment, target)
+        }
+        return super.process(resultingAssignment)
+    }
+
+    private fun processAssignmentTarget(assignment: Assignment, target: AssignTarget): Assignment {
+        if(target.identifier!=null) {
+            val targetName = target.identifier.nameInSource
             val targetSymbol = namespace.lookup(targetName, assignment)
             when {
                 targetSymbol == null -> {
                     checkResult.add(ExpressionError("undefined symbol: ${targetName.joinToString(".")}", assignment.position))
-                    return super.process(assignment)
+                    return assignment
                 }
                 targetSymbol !is VarDecl -> {
                     checkResult.add(SyntaxError("assignment LHS must be register or variable", assignment.position))
-                    return super.process(assignment)
+                    return assignment
                 }
                 targetSymbol.type == VarDeclType.CONST -> {
                     checkResult.add(ExpressionError("cannot assign new value to a constant", assignment.position))
-                    return super.process(assignment)
+                    return assignment
                 }
+                else -> {}
             }
         }
 
@@ -329,27 +338,27 @@ class AstChecker(private val namespace: INameScope,
         if(assignment.aug_op!=null) {
             // check augmented assignment:
             // A /= 3  -> check as if it was A = A / 3
-            val target: IExpression =
+            val newTarget: IExpression =
                     when {
-                        assignment.target.register!=null -> RegisterExpr(assignment.target.register!!, assignment.target.position)
-                        assignment.target.identifier!=null -> assignment.target.identifier!!
-                        assignment.target.arrayindexed!=null -> assignment.target.arrayindexed!!
+                        target.register!=null -> RegisterExpr(target.register, target.position)
+                        target.identifier!=null -> target.identifier
+                        target.arrayindexed!=null -> target.arrayindexed
                         else -> throw FatalAstException("strange assignment")
                     }
 
-            val expression = BinaryExpression(target, assignment.aug_op.substringBeforeLast('='), assignment.value, assignment.position)
+            val expression = BinaryExpression(newTarget, assignment.aug_op.substringBeforeLast('='), assignment.value, assignment.position)
             expression.linkParents(assignment.parent)
-            val assignment2 = Assignment(assignment.target, null, expression, assignment.position)
+            val assignment2 = Assignment(listOf(target), null, expression, assignment.position)
             assignment2.linkParents(assignment.parent)
-            return process(assignment2)
+            return assignment2
         }
 
-        val targetDatatype = assignment.target.determineDatatype(namespace, heap, assignment)
+        val targetDatatype = target.determineDatatype(namespace, heap, assignment)
         if(targetDatatype!=null) {
             val constVal = assignment.value.constValue(namespace, heap)
             if(constVal!=null) {
-                val arrayspec = if(assignment.target.identifier!=null) {
-                    val targetVar = namespace.lookup(assignment.target.identifier!!.nameInSource, assignment) as? VarDecl
+                val arrayspec = if(target.identifier!=null) {
+                    val targetVar = namespace.lookup(target.identifier.nameInSource, assignment) as? VarDecl
                     targetVar?.arrayspec
                 } else null
                 checkValueTypeAndRange(targetDatatype,
@@ -375,8 +384,7 @@ class AstChecker(private val namespace: INameScope,
                 }
             }
         }
-
-        return super.process(assignment)
+        return assignment
     }
 
 
diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt
index 033611820..f9195e50a 100644
--- a/compiler/src/prog8/compiler/Compiler.kt
+++ b/compiler/src/prog8/compiler/Compiler.kt
@@ -1089,10 +1089,11 @@ private class StatementTranslator(private val prog: IntermediateProgram,
     }
 
     private fun translate(stmt: Assignment) {
+        val assignTarget= stmt.singleTarget ?: throw CompilerException("cannot use assignment to multiple assignment targets ${stmt.position}")
         prog.line(stmt.position)
         translate(stmt.value)
         val valueDt = stmt.value.resultingDatatype(namespace, heap)
-        val targetDt = stmt.target.determineDatatype(namespace, heap, stmt)
+        val targetDt = assignTarget.determineDatatype(namespace, heap, stmt)
         if(valueDt!=targetDt) {
             // convert value to target datatype if possible
             when(targetDt) {
@@ -1124,26 +1125,26 @@ private class StatementTranslator(private val prog: IntermediateProgram,
         if(stmt.aug_op!=null) {
             // augmented assignment
             when {
-                stmt.target.identifier!=null -> {
-                    val target = stmt.target.identifier!!.targetStatement(namespace)!!
+                assignTarget.identifier!=null -> {
+                    val target = assignTarget.identifier.targetStatement(namespace)!!
                     when(target) {
                         is VarDecl -> {
-                            val opcode = opcodePushvar(stmt.target.determineDatatype(namespace, heap, stmt)!!)
+                            val opcode = opcodePushvar(assignTarget.determineDatatype(namespace, heap, stmt)!!)
                             prog.instr(opcode, callLabel = target.scopedname)
                         }
                         else -> throw CompilerException("invalid assignment target type ${target::class}")
                     }
                 }
-                stmt.target.register!=null -> prog.instr(Opcode.PUSH_VAR_BYTE, callLabel = stmt.target.register.toString())
-                stmt.target.arrayindexed!=null -> translate(stmt.target.arrayindexed!!, false)
+                assignTarget.register!=null -> prog.instr(Opcode.PUSH_VAR_BYTE, callLabel = assignTarget.register.toString())
+                assignTarget.arrayindexed!=null -> translate(assignTarget.arrayindexed, false)
             }
 
             translateAugAssignOperator(stmt.aug_op, stmt.value.resultingDatatype(namespace, heap))
         }
 
         // pop the result value back into the assignment target
-        val datatype = stmt.target.determineDatatype(namespace, heap, stmt)!!
-        popValueIntoTarget(stmt.target, datatype)
+        val datatype = assignTarget.determineDatatype(namespace, heap, stmt)!!
+        popValueIntoTarget(assignTarget, datatype)
     }
 
     private fun popValueIntoTarget(assignTarget: AssignTarget, datatype: DataType) {
@@ -1394,7 +1395,7 @@ private class StatementTranslator(private val prog: IntermediateProgram,
         else
             AssignTarget(null, loop.loopVar!!.copy(), null, loop.position)
         val arrayspec = ArraySpec(RegisterExpr(Register.X, loop.position), loop.position)
-        val assignLv = Assignment(assignTarget, null, ArrayIndexedExpression((loop.iterable as IdentifierReference).copy(), arrayspec, loop.position), loop.position)
+        val assignLv = Assignment(listOf(assignTarget), null, ArrayIndexedExpression((loop.iterable as IdentifierReference).copy(), arrayspec, loop.position), loop.position)
         assignLv.linkParents(loop.body)
         translate(assignLv)
         translate(loop.body)
@@ -1519,7 +1520,7 @@ private class StatementTranslator(private val prog: IntermediateProgram,
                 AssignTarget(register, null, null, range.position)
         }
 
-        val startAssignment = Assignment(makeAssignmentTarget(), null, range.from, range.position)
+        val startAssignment = Assignment(listOf(makeAssignmentTarget()), null, range.from, range.position)
         startAssignment.linkParents(range.parent)
         translate(startAssignment)
 
diff --git a/compiler/src/prog8/optimizing/ConstantFolding.kt b/compiler/src/prog8/optimizing/ConstantFolding.kt
index 60f038bb9..a10b9b128 100644
--- a/compiler/src/prog8/optimizing/ConstantFolding.kt
+++ b/compiler/src/prog8/optimizing/ConstantFolding.kt
@@ -536,7 +536,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV
         super.process(assignment)
         val lv = assignment.value as? LiteralValue
         if(lv!=null) {
-            val targetDt = assignment.target.determineDatatype(namespace, heap, assignment)
+            val targetDt = assignment.singleTarget?.determineDatatype(namespace, heap, assignment)
             // see if we can promote/convert a literal value to the required datatype
             when(targetDt) {
                 DataType.UWORD -> {
diff --git a/compiler/src/prog8/optimizing/StatementOptimizer.kt b/compiler/src/prog8/optimizing/StatementOptimizer.kt
index 7df179546..70e2bd75a 100644
--- a/compiler/src/prog8/optimizing/StatementOptimizer.kt
+++ b/compiler/src/prog8/optimizing/StatementOptimizer.kt
@@ -105,7 +105,7 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
             if(range.size()==1) {
                 // for loop over a (constant) range of just a single value-- optimize the loop away
                 // loopvar/reg = range value , follow by block
-                val assignment = Assignment(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, forLoop.position), null, range.from, forLoop.position)
+                val assignment = Assignment(listOf(AssignTarget(forLoop.loopRegister, forLoop.loopVar, null, forLoop.position)), null, range.from, forLoop.position)
                 forLoop.body.statements.add(0, assignment)
                 optimizationsDone++
                 return forLoop.body
@@ -174,4 +174,4 @@ class StatementOptimizer(private val namespace: INameScope, private val heap: He
         }
         return jump
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/src/prog8/parser/prog8Parser.java b/compiler/src/prog8/parser/prog8Parser.java
index 659d73288..037036102 100644
--- a/compiler/src/prog8/parser/prog8Parser.java
+++ b/compiler/src/prog8/parser/prog8Parser.java
@@ -39,33 +39,34 @@ public class prog8Parser extends Parser {
 		RULE_module = 0, RULE_modulestatement = 1, RULE_block = 2, RULE_statement = 3, 
 		RULE_labeldef = 4, RULE_unconditionaljump = 5, RULE_directive = 6, RULE_directivearg = 7, 
 		RULE_vardecl = 8, RULE_varinitializer = 9, RULE_constdecl = 10, RULE_memoryvardecl = 11, 
-		RULE_datatype = 12, RULE_arrayspec = 13, RULE_assignment = 14, RULE_augassignment = 15, 
-		RULE_assign_target = 16, RULE_postincrdecr = 17, RULE_expression = 18, 
-		RULE_arrayindexed = 19, RULE_functioncall = 20, RULE_functioncall_stmt = 21, 
-		RULE_expression_list = 22, RULE_returnstmt = 23, RULE_breakstmt = 24, 
-		RULE_continuestmt = 25, RULE_identifier = 26, RULE_scoped_identifier = 27, 
-		RULE_register = 28, RULE_registerorpair = 29, RULE_statusregister = 30, 
-		RULE_integerliteral = 31, RULE_wordsuffix = 32, RULE_booleanliteral = 33, 
-		RULE_arrayliteral = 34, RULE_stringliteral = 35, RULE_charliteral = 36, 
-		RULE_floatliteral = 37, RULE_literalvalue = 38, RULE_inlineasm = 39, RULE_subroutine = 40, 
-		RULE_sub_return_part = 41, RULE_statement_block = 42, RULE_sub_params = 43, 
-		RULE_sub_param = 44, RULE_sub_returns = 45, RULE_asmsubroutine = 46, RULE_asmsub_address = 47, 
-		RULE_asmsub_params = 48, RULE_asmsub_param = 49, RULE_clobber = 50, RULE_asmsub_returns = 51, 
-		RULE_asmsub_return = 52, RULE_if_stmt = 53, RULE_else_part = 54, RULE_branch_stmt = 55, 
-		RULE_branchcondition = 56, RULE_forloop = 57, RULE_whileloop = 58, RULE_repeatloop = 59;
+		RULE_datatype = 12, RULE_arrayspec = 13, RULE_assignment = 14, RULE_assign_targets = 15, 
+		RULE_augassignment = 16, RULE_assign_target = 17, RULE_postincrdecr = 18, 
+		RULE_expression = 19, RULE_arrayindexed = 20, RULE_functioncall = 21, 
+		RULE_functioncall_stmt = 22, RULE_expression_list = 23, RULE_returnstmt = 24, 
+		RULE_breakstmt = 25, RULE_continuestmt = 26, RULE_identifier = 27, RULE_scoped_identifier = 28, 
+		RULE_register = 29, RULE_registerorpair = 30, RULE_statusregister = 31, 
+		RULE_integerliteral = 32, RULE_wordsuffix = 33, RULE_booleanliteral = 34, 
+		RULE_arrayliteral = 35, RULE_stringliteral = 36, RULE_charliteral = 37, 
+		RULE_floatliteral = 38, RULE_literalvalue = 39, RULE_inlineasm = 40, RULE_subroutine = 41, 
+		RULE_sub_return_part = 42, RULE_statement_block = 43, RULE_sub_params = 44, 
+		RULE_sub_param = 45, RULE_sub_returns = 46, RULE_asmsubroutine = 47, RULE_asmsub_address = 48, 
+		RULE_asmsub_params = 49, RULE_asmsub_param = 50, RULE_clobber = 51, RULE_asmsub_returns = 52, 
+		RULE_asmsub_return = 53, RULE_if_stmt = 54, RULE_else_part = 55, RULE_branch_stmt = 56, 
+		RULE_branchcondition = 57, RULE_forloop = 58, RULE_whileloop = 59, RULE_repeatloop = 60;
 	public static final String[] ruleNames = {
 		"module", "modulestatement", "block", "statement", "labeldef", "unconditionaljump", 
 		"directive", "directivearg", "vardecl", "varinitializer", "constdecl", 
-		"memoryvardecl", "datatype", "arrayspec", "assignment", "augassignment", 
-		"assign_target", "postincrdecr", "expression", "arrayindexed", "functioncall", 
-		"functioncall_stmt", "expression_list", "returnstmt", "breakstmt", "continuestmt", 
-		"identifier", "scoped_identifier", "register", "registerorpair", "statusregister", 
-		"integerliteral", "wordsuffix", "booleanliteral", "arrayliteral", "stringliteral", 
-		"charliteral", "floatliteral", "literalvalue", "inlineasm", "subroutine", 
-		"sub_return_part", "statement_block", "sub_params", "sub_param", "sub_returns", 
-		"asmsubroutine", "asmsub_address", "asmsub_params", "asmsub_param", "clobber", 
-		"asmsub_returns", "asmsub_return", "if_stmt", "else_part", "branch_stmt", 
-		"branchcondition", "forloop", "whileloop", "repeatloop"
+		"memoryvardecl", "datatype", "arrayspec", "assignment", "assign_targets", 
+		"augassignment", "assign_target", "postincrdecr", "expression", "arrayindexed", 
+		"functioncall", "functioncall_stmt", "expression_list", "returnstmt", 
+		"breakstmt", "continuestmt", "identifier", "scoped_identifier", "register", 
+		"registerorpair", "statusregister", "integerliteral", "wordsuffix", "booleanliteral", 
+		"arrayliteral", "stringliteral", "charliteral", "floatliteral", "literalvalue", 
+		"inlineasm", "subroutine", "sub_return_part", "statement_block", "sub_params", 
+		"sub_param", "sub_returns", "asmsubroutine", "asmsub_address", "asmsub_params", 
+		"asmsub_param", "clobber", "asmsub_returns", "asmsub_return", "if_stmt", 
+		"else_part", "branch_stmt", "branchcondition", "forloop", "whileloop", 
+		"repeatloop"
 	};
 
 	private static final String[] _LITERAL_NAMES = {
@@ -171,12 +172,12 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(124);
+			setState(126);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (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__12))) != 0) || _la==EOL) {
 				{
-				setState(122);
+				setState(124);
 				_errHandler.sync(this);
 				switch (_input.LA(1)) {
 				case T__0:
@@ -191,13 +192,13 @@ public class prog8Parser extends Parser {
 				case T__11:
 				case T__12:
 					{
-					setState(120);
+					setState(122);
 					modulestatement();
 					}
 					break;
 				case EOL:
 					{
-					setState(121);
+					setState(123);
 					match(EOL);
 					}
 					break;
@@ -205,11 +206,11 @@ public class prog8Parser extends Parser {
 					throw new NoViableAltException(this);
 				}
 				}
-				setState(126);
+				setState(128);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(127);
+			setState(129);
 			match(EOF);
 			}
 		}
@@ -241,7 +242,7 @@ public class prog8Parser extends Parser {
 		ModulestatementContext _localctx = new ModulestatementContext(_ctx, getState());
 		enterRule(_localctx, 2, RULE_modulestatement);
 		try {
-			setState(131);
+			setState(133);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__3:
@@ -256,14 +257,14 @@ public class prog8Parser extends Parser {
 			case T__12:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(129);
+				setState(131);
 				directive();
 				}
 				break;
 			case T__0:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(130);
+				setState(132);
 				block();
 				}
 				break;
@@ -306,23 +307,23 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(133);
+			setState(135);
 			match(T__0);
-			setState(134);
-			identifier();
 			setState(136);
+			identifier();
+			setState(138);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & ((1L << (DEC_INTEGER - 113)) | (1L << (HEX_INTEGER - 113)) | (1L << (BIN_INTEGER - 113)))) != 0)) {
 				{
-				setState(135);
+				setState(137);
 				integerliteral();
 				}
 			}
 
-			setState(138);
+			setState(140);
 			statement_block();
-			setState(139);
+			setState(141);
 			match(EOL);
 			}
 		}
@@ -414,160 +415,160 @@ public class prog8Parser extends Parser {
 		StatementContext _localctx = new StatementContext(_ctx, getState());
 		enterRule(_localctx, 6, RULE_statement);
 		try {
-			setState(163);
+			setState(165);
 			_errHandler.sync(this);
 			switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(141);
+				setState(143);
 				directive();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(142);
+				setState(144);
 				varinitializer();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(143);
+				setState(145);
 				vardecl();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(144);
+				setState(146);
 				constdecl();
 				}
 				break;
 			case 5:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(145);
+				setState(147);
 				memoryvardecl();
 				}
 				break;
 			case 6:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(146);
+				setState(148);
 				assignment();
 				}
 				break;
 			case 7:
 				enterOuterAlt(_localctx, 7);
 				{
-				setState(147);
+				setState(149);
 				augassignment();
 				}
 				break;
 			case 8:
 				enterOuterAlt(_localctx, 8);
 				{
-				setState(148);
+				setState(150);
 				unconditionaljump();
 				}
 				break;
 			case 9:
 				enterOuterAlt(_localctx, 9);
 				{
-				setState(149);
+				setState(151);
 				postincrdecr();
 				}
 				break;
 			case 10:
 				enterOuterAlt(_localctx, 10);
 				{
-				setState(150);
+				setState(152);
 				functioncall_stmt();
 				}
 				break;
 			case 11:
 				enterOuterAlt(_localctx, 11);
 				{
-				setState(151);
+				setState(153);
 				if_stmt();
 				}
 				break;
 			case 12:
 				enterOuterAlt(_localctx, 12);
 				{
-				setState(152);
+				setState(154);
 				branch_stmt();
 				}
 				break;
 			case 13:
 				enterOuterAlt(_localctx, 13);
 				{
-				setState(153);
+				setState(155);
 				subroutine();
 				}
 				break;
 			case 14:
 				enterOuterAlt(_localctx, 14);
 				{
-				setState(154);
+				setState(156);
 				asmsubroutine();
 				}
 				break;
 			case 15:
 				enterOuterAlt(_localctx, 15);
 				{
-				setState(155);
+				setState(157);
 				inlineasm();
 				}
 				break;
 			case 16:
 				enterOuterAlt(_localctx, 16);
 				{
-				setState(156);
+				setState(158);
 				returnstmt();
 				}
 				break;
 			case 17:
 				enterOuterAlt(_localctx, 17);
 				{
-				setState(157);
+				setState(159);
 				forloop();
 				}
 				break;
 			case 18:
 				enterOuterAlt(_localctx, 18);
 				{
-				setState(158);
+				setState(160);
 				whileloop();
 				}
 				break;
 			case 19:
 				enterOuterAlt(_localctx, 19);
 				{
-				setState(159);
+				setState(161);
 				repeatloop();
 				}
 				break;
 			case 20:
 				enterOuterAlt(_localctx, 20);
 				{
-				setState(160);
+				setState(162);
 				breakstmt();
 				}
 				break;
 			case 21:
 				enterOuterAlt(_localctx, 21);
 				{
-				setState(161);
+				setState(163);
 				continuestmt();
 				}
 				break;
 			case 22:
 				enterOuterAlt(_localctx, 22);
 				{
-				setState(162);
+				setState(164);
 				labeldef();
 				}
 				break;
@@ -600,9 +601,9 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(165);
+			setState(167);
 			identifier();
-			setState(166);
+			setState(168);
 			match(T__1);
 			}
 		}
@@ -639,26 +640,26 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(168);
+			setState(170);
 			match(T__2);
-			setState(172);
+			setState(174);
 			_errHandler.sync(this);
 			switch ( getInterpreter().adaptivePredict(_input,5,_ctx) ) {
 			case 1:
 				{
-				setState(169);
+				setState(171);
 				integerliteral();
 				}
 				break;
 			case 2:
 				{
-				setState(170);
+				setState(172);
 				identifier();
 				}
 				break;
 			case 3:
 				{
-				setState(171);
+				setState(173);
 				scoped_identifier();
 				}
 				break;
@@ -697,7 +698,7 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(174);
+			setState(176);
 			((DirectiveContext)_localctx).directivename = _input.LT(1);
 			_la = _input.LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((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__12))) != 0)) ) {
@@ -708,17 +709,17 @@ public class prog8Parser extends Parser {
 				_errHandler.reportMatch(this);
 				consume();
 			}
-			setState(186);
+			setState(188);
 			_errHandler.sync(this);
 			switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) {
 			case 1:
 				{
-				setState(176);
+				setState(178);
 				_errHandler.sync(this);
 				switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) {
 				case 1:
 					{
-					setState(175);
+					setState(177);
 					directivearg();
 					}
 					break;
@@ -727,21 +728,21 @@ public class prog8Parser extends Parser {
 				break;
 			case 2:
 				{
-				setState(178);
+				setState(180);
 				directivearg();
-				setState(183);
+				setState(185);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				while (_la==T__13) {
 					{
 					{
-					setState(179);
+					setState(181);
 					match(T__13);
-					setState(180);
+					setState(182);
 					directivearg();
 					}
 					}
-					setState(185);
+					setState(187);
 					_errHandler.sync(this);
 					_la = _input.LA(1);
 				}
@@ -781,20 +782,20 @@ public class prog8Parser extends Parser {
 		DirectiveargContext _localctx = new DirectiveargContext(_ctx, getState());
 		enterRule(_localctx, 14, RULE_directivearg);
 		try {
-			setState(191);
+			setState(193);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case STRING:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(188);
+				setState(190);
 				stringliteral();
 				}
 				break;
 			case NAME:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(189);
+				setState(191);
 				identifier();
 				}
 				break;
@@ -803,7 +804,7 @@ public class prog8Parser extends Parser {
 			case BIN_INTEGER:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(190);
+				setState(192);
 				integerliteral();
 				}
 				break;
@@ -845,19 +846,19 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(193);
-			datatype();
 			setState(195);
+			datatype();
+			setState(197);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==T__26) {
 				{
-				setState(194);
+				setState(196);
 				arrayspec();
 				}
 			}
 
-			setState(197);
+			setState(199);
 			identifier();
 			}
 		}
@@ -898,23 +899,23 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(199);
-			datatype();
 			setState(201);
+			datatype();
+			setState(203);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==T__26) {
 				{
-				setState(200);
+				setState(202);
 				arrayspec();
 				}
 			}
 
-			setState(203);
-			identifier();
-			setState(204);
-			match(T__14);
 			setState(205);
+			identifier();
+			setState(206);
+			match(T__14);
+			setState(207);
 			expression(0);
 			}
 		}
@@ -945,9 +946,9 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(207);
+			setState(209);
 			match(T__15);
-			setState(208);
+			setState(210);
 			varinitializer();
 			}
 		}
@@ -978,9 +979,9 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(210);
+			setState(212);
 			match(T__16);
-			setState(211);
+			setState(213);
 			varinitializer();
 			}
 		}
@@ -1009,7 +1010,7 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(213);
+			setState(215);
 			_la = _input.LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -1048,11 +1049,11 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(215);
-			match(T__26);
-			setState(216);
-			expression(0);
 			setState(217);
+			match(T__26);
+			setState(218);
+			expression(0);
+			setState(219);
 			match(T__27);
 			}
 		}
@@ -1068,8 +1069,8 @@ public class prog8Parser extends Parser {
 	}
 
 	public static class AssignmentContext extends ParserRuleContext {
-		public Assign_targetContext assign_target() {
-			return getRuleContext(Assign_targetContext.class,0);
+		public Assign_targetsContext assign_targets() {
+			return getRuleContext(Assign_targetsContext.class,0);
 		}
 		public ExpressionContext expression() {
 			return getRuleContext(ExpressionContext.class,0);
@@ -1086,11 +1087,11 @@ public class prog8Parser extends Parser {
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(219);
-			assign_target();
-			setState(220);
-			match(T__14);
 			setState(221);
+			assign_targets();
+			setState(222);
+			match(T__14);
+			setState(223);
 			expression(0);
 			}
 		}
@@ -1105,6 +1106,57 @@ public class prog8Parser extends Parser {
 		return _localctx;
 	}
 
+	public static class Assign_targetsContext extends ParserRuleContext {
+		public List<Assign_targetContext> assign_target() {
+			return getRuleContexts(Assign_targetContext.class);
+		}
+		public Assign_targetContext assign_target(int i) {
+			return getRuleContext(Assign_targetContext.class,i);
+		}
+		public Assign_targetsContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_assign_targets; }
+	}
+
+	public final Assign_targetsContext assign_targets() throws RecognitionException {
+		Assign_targetsContext _localctx = new Assign_targetsContext(_ctx, getState());
+		enterRule(_localctx, 30, RULE_assign_targets);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(225);
+			assign_target();
+			setState(230);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			while (_la==T__13) {
+				{
+				{
+				setState(226);
+				match(T__13);
+				setState(227);
+				assign_target();
+				}
+				}
+				setState(232);
+				_errHandler.sync(this);
+				_la = _input.LA(1);
+			}
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
 	public static class AugassignmentContext extends ParserRuleContext {
 		public Token operator;
 		public Assign_targetContext assign_target() {
@@ -1121,14 +1173,14 @@ public class prog8Parser extends Parser {
 
 	public final AugassignmentContext augassignment() throws RecognitionException {
 		AugassignmentContext _localctx = new AugassignmentContext(_ctx, getState());
-		enterRule(_localctx, 30, RULE_augassignment);
+		enterRule(_localctx, 32, RULE_augassignment);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(223);
+			setState(233);
 			assign_target();
-			setState(224);
+			setState(234);
 			((AugassignmentContext)_localctx).operator = _input.LT(1);
 			_la = _input.LA(1);
 			if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((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)) ) {
@@ -1139,7 +1191,7 @@ public class prog8Parser extends Parser {
 				_errHandler.reportMatch(this);
 				consume();
 			}
-			setState(225);
+			setState(235);
 			expression(0);
 			}
 		}
@@ -1175,36 +1227,36 @@ public class prog8Parser extends Parser {
 
 	public final Assign_targetContext assign_target() throws RecognitionException {
 		Assign_targetContext _localctx = new Assign_targetContext(_ctx, getState());
-		enterRule(_localctx, 32, RULE_assign_target);
+		enterRule(_localctx, 34, RULE_assign_target);
 		try {
-			setState(231);
+			setState(241);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,12,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
 			case 1:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(227);
+				setState(237);
 				register();
 				}
 				break;
 			case 2:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(228);
+				setState(238);
 				identifier();
 				}
 				break;
 			case 3:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(229);
+				setState(239);
 				scoped_identifier();
 				}
 				break;
 			case 4:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(230);
+				setState(240);
 				arrayindexed();
 				}
 				break;
@@ -1234,14 +1286,14 @@ public class prog8Parser extends Parser {
 
 	public final PostincrdecrContext postincrdecr() throws RecognitionException {
 		PostincrdecrContext _localctx = new PostincrdecrContext(_ctx, getState());
-		enterRule(_localctx, 34, RULE_postincrdecr);
+		enterRule(_localctx, 36, RULE_postincrdecr);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(233);
+			setState(243);
 			assign_target();
-			setState(234);
+			setState(244);
 			((PostincrdecrContext)_localctx).operator = _input.LT(1);
 			_la = _input.LA(1);
 			if ( !(_la==T__37 || _la==T__38) ) {
@@ -1312,35 +1364,35 @@ public class prog8Parser extends Parser {
 		int _parentState = getState();
 		ExpressionContext _localctx = new ExpressionContext(_ctx, _parentState);
 		ExpressionContext _prevctx = _localctx;
-		int _startState = 36;
-		enterRecursionRule(_localctx, 36, RULE_expression, _p);
+		int _startState = 38;
+		enterRecursionRule(_localctx, 38, RULE_expression, _p);
 		int _la;
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(251);
+			setState(261);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
 			case 1:
 				{
-				setState(237);
+				setState(247);
 				match(T__39);
-				setState(238);
+				setState(248);
 				expression(0);
-				setState(239);
+				setState(249);
 				match(T__40);
 				}
 				break;
 			case 2:
 				{
-				setState(241);
+				setState(251);
 				functioncall();
 				}
 				break;
 			case 3:
 				{
-				setState(242);
+				setState(252);
 				((ExpressionContext)_localctx).prefix = _input.LT(1);
 				_la = _input.LA(1);
 				if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__41) | (1L << T__42))) != 0)) ) {
@@ -1351,72 +1403,72 @@ public class prog8Parser extends Parser {
 					_errHandler.reportMatch(this);
 					consume();
 				}
-				setState(243);
+				setState(253);
 				expression(19);
 				}
 				break;
 			case 4:
 				{
-				setState(244);
+				setState(254);
 				((ExpressionContext)_localctx).prefix = match(T__62);
-				setState(245);
+				setState(255);
 				expression(6);
 				}
 				break;
 			case 5:
 				{
-				setState(246);
+				setState(256);
 				literalvalue();
 				}
 				break;
 			case 6:
 				{
-				setState(247);
+				setState(257);
 				register();
 				}
 				break;
 			case 7:
 				{
-				setState(248);
+				setState(258);
 				identifier();
 				}
 				break;
 			case 8:
 				{
-				setState(249);
+				setState(259);
 				scoped_identifier();
 				}
 				break;
 			case 9:
 				{
-				setState(250);
+				setState(260);
 				arrayindexed();
 				}
 				break;
 			}
 			_ctx.stop = _input.LT(-1);
-			setState(295);
+			setState(305);
 			_errHandler.sync(this);
-			_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
+			_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
 			while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) {
 				if ( _alt==1 ) {
 					if ( _parseListeners!=null ) triggerExitRuleEvent();
 					_prevctx = _localctx;
 					{
-					setState(293);
+					setState(303);
 					_errHandler.sync(this);
-					switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
+					switch ( getInterpreter().adaptivePredict(_input,16,_ctx) ) {
 					case 1:
 						{
 						_localctx = new ExpressionContext(_parentctx, _parentState);
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(253);
+						setState(263);
 						if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)");
-						setState(254);
+						setState(264);
 						((ExpressionContext)_localctx).bop = match(T__43);
-						setState(255);
+						setState(265);
 						((ExpressionContext)_localctx).right = expression(19);
 						}
 						break;
@@ -1426,9 +1478,9 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(256);
+						setState(266);
 						if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)");
-						setState(257);
+						setState(267);
 						((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) | (1L << T__47))) != 0)) ) {
@@ -1439,7 +1491,7 @@ public class prog8Parser extends Parser {
 							_errHandler.reportMatch(this);
 							consume();
 						}
-						setState(258);
+						setState(268);
 						((ExpressionContext)_localctx).right = expression(18);
 						}
 						break;
@@ -1449,9 +1501,9 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(259);
+						setState(269);
 						if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)");
-						setState(260);
+						setState(270);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
 						if ( !(_la==T__41 || _la==T__42) ) {
@@ -1462,7 +1514,7 @@ public class prog8Parser extends Parser {
 							_errHandler.reportMatch(this);
 							consume();
 						}
-						setState(261);
+						setState(271);
 						((ExpressionContext)_localctx).right = expression(17);
 						}
 						break;
@@ -1472,9 +1524,9 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(262);
+						setState(272);
 						if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)");
-						setState(263);
+						setState(273);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
 						if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__48) | (1L << T__49) | (1L << T__50) | (1L << T__51))) != 0)) ) {
@@ -1485,7 +1537,7 @@ public class prog8Parser extends Parser {
 							_errHandler.reportMatch(this);
 							consume();
 						}
-						setState(264);
+						setState(274);
 						((ExpressionContext)_localctx).right = expression(16);
 						}
 						break;
@@ -1495,9 +1547,9 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(265);
+						setState(275);
 						if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)");
-						setState(266);
+						setState(276);
 						((ExpressionContext)_localctx).bop = _input.LT(1);
 						_la = _input.LA(1);
 						if ( !(_la==T__52 || _la==T__53) ) {
@@ -1508,7 +1560,7 @@ public class prog8Parser extends Parser {
 							_errHandler.reportMatch(this);
 							consume();
 						}
-						setState(267);
+						setState(277);
 						((ExpressionContext)_localctx).right = expression(15);
 						}
 						break;
@@ -1518,11 +1570,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(268);
+						setState(278);
 						if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)");
-						setState(269);
+						setState(279);
 						((ExpressionContext)_localctx).bop = match(T__54);
-						setState(270);
+						setState(280);
 						((ExpressionContext)_localctx).right = expression(14);
 						}
 						break;
@@ -1532,11 +1584,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(271);
+						setState(281);
 						if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)");
-						setState(272);
+						setState(282);
 						((ExpressionContext)_localctx).bop = match(T__55);
-						setState(273);
+						setState(283);
 						((ExpressionContext)_localctx).right = expression(13);
 						}
 						break;
@@ -1546,11 +1598,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(274);
+						setState(284);
 						if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)");
-						setState(275);
+						setState(285);
 						((ExpressionContext)_localctx).bop = match(T__56);
-						setState(276);
+						setState(286);
 						((ExpressionContext)_localctx).right = expression(12);
 						}
 						break;
@@ -1560,11 +1612,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(277);
+						setState(287);
 						if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)");
-						setState(278);
+						setState(288);
 						((ExpressionContext)_localctx).bop = match(T__59);
-						setState(279);
+						setState(289);
 						((ExpressionContext)_localctx).right = expression(10);
 						}
 						break;
@@ -1574,11 +1626,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(280);
+						setState(290);
 						if (!(precpred(_ctx, 8))) throw new FailedPredicateException(this, "precpred(_ctx, 8)");
-						setState(281);
+						setState(291);
 						((ExpressionContext)_localctx).bop = match(T__60);
-						setState(282);
+						setState(292);
 						((ExpressionContext)_localctx).right = expression(9);
 						}
 						break;
@@ -1588,11 +1640,11 @@ public class prog8Parser extends Parser {
 						_localctx.left = _prevctx;
 						_localctx.left = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(283);
+						setState(293);
 						if (!(precpred(_ctx, 7))) throw new FailedPredicateException(this, "precpred(_ctx, 7)");
-						setState(284);
+						setState(294);
 						((ExpressionContext)_localctx).bop = match(T__61);
-						setState(285);
+						setState(295);
 						((ExpressionContext)_localctx).right = expression(8);
 						}
 						break;
@@ -1602,20 +1654,20 @@ public class prog8Parser extends Parser {
 						_localctx.rangefrom = _prevctx;
 						_localctx.rangefrom = _prevctx;
 						pushNewRecursionContext(_localctx, _startState, RULE_expression);
-						setState(286);
+						setState(296);
 						if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)");
-						setState(287);
+						setState(297);
 						match(T__57);
-						setState(288);
+						setState(298);
 						((ExpressionContext)_localctx).rangeto = expression(0);
-						setState(291);
+						setState(301);
 						_errHandler.sync(this);
-						switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) {
+						switch ( getInterpreter().adaptivePredict(_input,15,_ctx) ) {
 						case 1:
 							{
-							setState(289);
+							setState(299);
 							match(T__58);
-							setState(290);
+							setState(300);
 							((ExpressionContext)_localctx).rangestep = expression(0);
 							}
 							break;
@@ -1625,9 +1677,9 @@ public class prog8Parser extends Parser {
 					}
 					} 
 				}
-				setState(297);
+				setState(307);
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,16,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,17,_ctx);
 			}
 			}
 		}
@@ -1660,27 +1712,27 @@ public class prog8Parser extends Parser {
 
 	public final ArrayindexedContext arrayindexed() throws RecognitionException {
 		ArrayindexedContext _localctx = new ArrayindexedContext(_ctx, getState());
-		enterRule(_localctx, 38, RULE_arrayindexed);
+		enterRule(_localctx, 40, RULE_arrayindexed);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(300);
+			setState(310);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,17,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
 			case 1:
 				{
-				setState(298);
+				setState(308);
 				identifier();
 				}
 				break;
 			case 2:
 				{
-				setState(299);
+				setState(309);
 				scoped_identifier();
 				}
 				break;
 			}
-			setState(302);
+			setState(312);
 			arrayspec();
 			}
 		}
@@ -1713,80 +1765,14 @@ public class prog8Parser extends Parser {
 
 	public final FunctioncallContext functioncall() throws RecognitionException {
 		FunctioncallContext _localctx = new FunctioncallContext(_ctx, getState());
-		enterRule(_localctx, 40, RULE_functioncall);
-		int _la;
-		try {
-			enterOuterAlt(_localctx, 1);
-			{
-			setState(306);
-			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,18,_ctx) ) {
-			case 1:
-				{
-				setState(304);
-				identifier();
-				}
-				break;
-			case 2:
-				{
-				setState(305);
-				scoped_identifier();
-				}
-				break;
-			}
-			setState(308);
-			match(T__39);
-			setState(310);
-			_errHandler.sync(this);
-			_la = _input.LA(1);
-			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__26) | (1L << T__39) | (1L << T__41) | (1L << T__42) | (1L << T__62))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__68 - 68)) | (1L << (T__69 - 68)) | (1L << (T__78 - 68)) | (1L << (T__79 - 68)) | (1L << (NAME - 68)) | (1L << (DEC_INTEGER - 68)) | (1L << (HEX_INTEGER - 68)) | (1L << (BIN_INTEGER - 68)) | (1L << (FLOAT_NUMBER - 68)) | (1L << (STRING - 68)) | (1L << (SINGLECHAR - 68)))) != 0)) {
-				{
-				setState(309);
-				expression_list();
-				}
-			}
-
-			setState(312);
-			match(T__40);
-			}
-		}
-		catch (RecognitionException re) {
-			_localctx.exception = re;
-			_errHandler.reportError(this, re);
-			_errHandler.recover(this, re);
-		}
-		finally {
-			exitRule();
-		}
-		return _localctx;
-	}
-
-	public static class Functioncall_stmtContext extends ParserRuleContext {
-		public IdentifierContext identifier() {
-			return getRuleContext(IdentifierContext.class,0);
-		}
-		public Scoped_identifierContext scoped_identifier() {
-			return getRuleContext(Scoped_identifierContext.class,0);
-		}
-		public Expression_listContext expression_list() {
-			return getRuleContext(Expression_listContext.class,0);
-		}
-		public Functioncall_stmtContext(ParserRuleContext parent, int invokingState) {
-			super(parent, invokingState);
-		}
-		@Override public int getRuleIndex() { return RULE_functioncall_stmt; }
-	}
-
-	public final Functioncall_stmtContext functioncall_stmt() throws RecognitionException {
-		Functioncall_stmtContext _localctx = new Functioncall_stmtContext(_ctx, getState());
-		enterRule(_localctx, 42, RULE_functioncall_stmt);
+		enterRule(_localctx, 42, RULE_functioncall);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
 			setState(316);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,20,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,19,_ctx) ) {
 			case 1:
 				{
 				setState(314);
@@ -1827,6 +1813,72 @@ public class prog8Parser extends Parser {
 		return _localctx;
 	}
 
+	public static class Functioncall_stmtContext extends ParserRuleContext {
+		public IdentifierContext identifier() {
+			return getRuleContext(IdentifierContext.class,0);
+		}
+		public Scoped_identifierContext scoped_identifier() {
+			return getRuleContext(Scoped_identifierContext.class,0);
+		}
+		public Expression_listContext expression_list() {
+			return getRuleContext(Expression_listContext.class,0);
+		}
+		public Functioncall_stmtContext(ParserRuleContext parent, int invokingState) {
+			super(parent, invokingState);
+		}
+		@Override public int getRuleIndex() { return RULE_functioncall_stmt; }
+	}
+
+	public final Functioncall_stmtContext functioncall_stmt() throws RecognitionException {
+		Functioncall_stmtContext _localctx = new Functioncall_stmtContext(_ctx, getState());
+		enterRule(_localctx, 44, RULE_functioncall_stmt);
+		int _la;
+		try {
+			enterOuterAlt(_localctx, 1);
+			{
+			setState(326);
+			_errHandler.sync(this);
+			switch ( getInterpreter().adaptivePredict(_input,21,_ctx) ) {
+			case 1:
+				{
+				setState(324);
+				identifier();
+				}
+				break;
+			case 2:
+				{
+				setState(325);
+				scoped_identifier();
+				}
+				break;
+			}
+			setState(328);
+			match(T__39);
+			setState(330);
+			_errHandler.sync(this);
+			_la = _input.LA(1);
+			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__26) | (1L << T__39) | (1L << T__41) | (1L << T__42) | (1L << T__62))) != 0) || ((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__68 - 68)) | (1L << (T__69 - 68)) | (1L << (T__78 - 68)) | (1L << (T__79 - 68)) | (1L << (NAME - 68)) | (1L << (DEC_INTEGER - 68)) | (1L << (HEX_INTEGER - 68)) | (1L << (BIN_INTEGER - 68)) | (1L << (FLOAT_NUMBER - 68)) | (1L << (STRING - 68)) | (1L << (SINGLECHAR - 68)))) != 0)) {
+				{
+				setState(329);
+				expression_list();
+				}
+			}
+
+			setState(332);
+			match(T__40);
+			}
+		}
+		catch (RecognitionException re) {
+			_localctx.exception = re;
+			_errHandler.reportError(this, re);
+			_errHandler.recover(this, re);
+		}
+		finally {
+			exitRule();
+		}
+		return _localctx;
+	}
+
 	public static class Expression_listContext extends ParserRuleContext {
 		public List<ExpressionContext> expression() {
 			return getRuleContexts(ExpressionContext.class);
@@ -1846,36 +1898,36 @@ public class prog8Parser extends Parser {
 
 	public final Expression_listContext expression_list() throws RecognitionException {
 		Expression_listContext _localctx = new Expression_listContext(_ctx, getState());
-		enterRule(_localctx, 44, RULE_expression_list);
+		enterRule(_localctx, 46, RULE_expression_list);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(324);
+			setState(334);
 			expression(0);
-			setState(332);
+			setState(342);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(325);
+				setState(335);
 				match(T__13);
-				setState(327);
+				setState(337);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(326);
+					setState(336);
 					match(EOL);
 					}
 				}
 
-				setState(329);
+				setState(339);
 				expression(0);
 				}
 				}
-				setState(334);
+				setState(344);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -1904,18 +1956,18 @@ public class prog8Parser extends Parser {
 
 	public final ReturnstmtContext returnstmt() throws RecognitionException {
 		ReturnstmtContext _localctx = new ReturnstmtContext(_ctx, getState());
-		enterRule(_localctx, 46, RULE_returnstmt);
+		enterRule(_localctx, 48, RULE_returnstmt);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(335);
+			setState(345);
 			match(T__63);
-			setState(337);
+			setState(347);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,24,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,25,_ctx) ) {
 			case 1:
 				{
-				setState(336);
+				setState(346);
 				expression_list();
 				}
 				break;
@@ -1942,11 +1994,11 @@ public class prog8Parser extends Parser {
 
 	public final BreakstmtContext breakstmt() throws RecognitionException {
 		BreakstmtContext _localctx = new BreakstmtContext(_ctx, getState());
-		enterRule(_localctx, 48, RULE_breakstmt);
+		enterRule(_localctx, 50, RULE_breakstmt);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(339);
+			setState(349);
 			match(T__64);
 			}
 		}
@@ -1970,11 +2022,11 @@ public class prog8Parser extends Parser {
 
 	public final ContinuestmtContext continuestmt() throws RecognitionException {
 		ContinuestmtContext _localctx = new ContinuestmtContext(_ctx, getState());
-		enterRule(_localctx, 50, RULE_continuestmt);
+		enterRule(_localctx, 52, RULE_continuestmt);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(341);
+			setState(351);
 			match(T__65);
 			}
 		}
@@ -1999,11 +2051,11 @@ public class prog8Parser extends Parser {
 
 	public final IdentifierContext identifier() throws RecognitionException {
 		IdentifierContext _localctx = new IdentifierContext(_ctx, getState());
-		enterRule(_localctx, 52, RULE_identifier);
+		enterRule(_localctx, 54, RULE_identifier);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(343);
+			setState(353);
 			match(NAME);
 			}
 		}
@@ -2031,14 +2083,14 @@ public class prog8Parser extends Parser {
 
 	public final Scoped_identifierContext scoped_identifier() throws RecognitionException {
 		Scoped_identifierContext _localctx = new Scoped_identifierContext(_ctx, getState());
-		enterRule(_localctx, 54, RULE_scoped_identifier);
+		enterRule(_localctx, 56, RULE_scoped_identifier);
 		try {
 			int _alt;
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(345);
+			setState(355);
 			match(NAME);
-			setState(348); 
+			setState(358); 
 			_errHandler.sync(this);
 			_alt = 1;
 			do {
@@ -2046,9 +2098,9 @@ public class prog8Parser extends Parser {
 				case 1:
 					{
 					{
-					setState(346);
+					setState(356);
 					match(T__66);
-					setState(347);
+					setState(357);
 					match(NAME);
 					}
 					}
@@ -2056,9 +2108,9 @@ public class prog8Parser extends Parser {
 				default:
 					throw new NoViableAltException(this);
 				}
-				setState(350); 
+				setState(360); 
 				_errHandler.sync(this);
-				_alt = getInterpreter().adaptivePredict(_input,25,_ctx);
+				_alt = getInterpreter().adaptivePredict(_input,26,_ctx);
 			} while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER );
 			}
 		}
@@ -2082,12 +2134,12 @@ public class prog8Parser extends Parser {
 
 	public final RegisterContext register() throws RecognitionException {
 		RegisterContext _localctx = new RegisterContext(_ctx, getState());
-		enterRule(_localctx, 56, RULE_register);
+		enterRule(_localctx, 58, RULE_register);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(352);
+			setState(362);
 			_la = _input.LA(1);
 			if ( !(((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__68 - 68)) | (1L << (T__69 - 68)))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -2119,12 +2171,12 @@ public class prog8Parser extends Parser {
 
 	public final RegisterorpairContext registerorpair() throws RecognitionException {
 		RegisterorpairContext _localctx = new RegisterorpairContext(_ctx, getState());
-		enterRule(_localctx, 58, RULE_registerorpair);
+		enterRule(_localctx, 60, RULE_registerorpair);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(354);
+			setState(364);
 			_la = _input.LA(1);
 			if ( !(((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__68 - 68)) | (1L << (T__69 - 68)) | (1L << (T__70 - 68)) | (1L << (T__71 - 68)) | (1L << (T__72 - 68)))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -2156,12 +2208,12 @@ public class prog8Parser extends Parser {
 
 	public final StatusregisterContext statusregister() throws RecognitionException {
 		StatusregisterContext _localctx = new StatusregisterContext(_ctx, getState());
-		enterRule(_localctx, 60, RULE_statusregister);
+		enterRule(_localctx, 62, RULE_statusregister);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(356);
+			setState(366);
 			_la = _input.LA(1);
 			if ( !(((((_la - 74)) & ~0x3f) == 0 && ((1L << (_la - 74)) & ((1L << (T__73 - 74)) | (1L << (T__74 - 74)) | (1L << (T__75 - 74)) | (1L << (T__76 - 74)))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -2200,12 +2252,12 @@ public class prog8Parser extends Parser {
 
 	public final IntegerliteralContext integerliteral() throws RecognitionException {
 		IntegerliteralContext _localctx = new IntegerliteralContext(_ctx, getState());
-		enterRule(_localctx, 62, RULE_integerliteral);
+		enterRule(_localctx, 64, RULE_integerliteral);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(358);
+			setState(368);
 			((IntegerliteralContext)_localctx).intpart = _input.LT(1);
 			_la = _input.LA(1);
 			if ( !(((((_la - 113)) & ~0x3f) == 0 && ((1L << (_la - 113)) & ((1L << (DEC_INTEGER - 113)) | (1L << (HEX_INTEGER - 113)) | (1L << (BIN_INTEGER - 113)))) != 0)) ) {
@@ -2216,12 +2268,12 @@ public class prog8Parser extends Parser {
 				_errHandler.reportMatch(this);
 				consume();
 			}
-			setState(360);
+			setState(370);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,26,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,27,_ctx) ) {
 			case 1:
 				{
-				setState(359);
+				setState(369);
 				wordsuffix();
 				}
 				break;
@@ -2248,11 +2300,11 @@ public class prog8Parser extends Parser {
 
 	public final WordsuffixContext wordsuffix() throws RecognitionException {
 		WordsuffixContext _localctx = new WordsuffixContext(_ctx, getState());
-		enterRule(_localctx, 64, RULE_wordsuffix);
+		enterRule(_localctx, 66, RULE_wordsuffix);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(362);
+			setState(372);
 			match(T__77);
 			}
 		}
@@ -2276,12 +2328,12 @@ public class prog8Parser extends Parser {
 
 	public final BooleanliteralContext booleanliteral() throws RecognitionException {
 		BooleanliteralContext _localctx = new BooleanliteralContext(_ctx, getState());
-		enterRule(_localctx, 66, RULE_booleanliteral);
+		enterRule(_localctx, 68, RULE_booleanliteral);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(364);
+			setState(374);
 			_la = _input.LA(1);
 			if ( !(_la==T__78 || _la==T__79) ) {
 			_errHandler.recoverInline(this);
@@ -2323,62 +2375,62 @@ public class prog8Parser extends Parser {
 
 	public final ArrayliteralContext arrayliteral() throws RecognitionException {
 		ArrayliteralContext _localctx = new ArrayliteralContext(_ctx, getState());
-		enterRule(_localctx, 68, RULE_arrayliteral);
+		enterRule(_localctx, 70, RULE_arrayliteral);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(366);
+			setState(376);
 			match(T__26);
-			setState(368);
+			setState(378);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(367);
+				setState(377);
 				match(EOL);
 				}
 			}
 
-			setState(370);
+			setState(380);
 			expression(0);
-			setState(378);
+			setState(388);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(371);
+				setState(381);
 				match(T__13);
-				setState(373);
+				setState(383);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(372);
+					setState(382);
 					match(EOL);
 					}
 				}
 
-				setState(375);
+				setState(385);
 				expression(0);
 				}
 				}
-				setState(380);
+				setState(390);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(382);
+			setState(392);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(381);
+				setState(391);
 				match(EOL);
 				}
 			}
 
-			setState(384);
+			setState(394);
 			match(T__27);
 			}
 		}
@@ -2403,11 +2455,11 @@ public class prog8Parser extends Parser {
 
 	public final StringliteralContext stringliteral() throws RecognitionException {
 		StringliteralContext _localctx = new StringliteralContext(_ctx, getState());
-		enterRule(_localctx, 70, RULE_stringliteral);
+		enterRule(_localctx, 72, RULE_stringliteral);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(386);
+			setState(396);
 			match(STRING);
 			}
 		}
@@ -2432,11 +2484,11 @@ public class prog8Parser extends Parser {
 
 	public final CharliteralContext charliteral() throws RecognitionException {
 		CharliteralContext _localctx = new CharliteralContext(_ctx, getState());
-		enterRule(_localctx, 72, RULE_charliteral);
+		enterRule(_localctx, 74, RULE_charliteral);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(388);
+			setState(398);
 			match(SINGLECHAR);
 			}
 		}
@@ -2461,11 +2513,11 @@ public class prog8Parser extends Parser {
 
 	public final FloatliteralContext floatliteral() throws RecognitionException {
 		FloatliteralContext _localctx = new FloatliteralContext(_ctx, getState());
-		enterRule(_localctx, 74, RULE_floatliteral);
+		enterRule(_localctx, 76, RULE_floatliteral);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(390);
+			setState(400);
 			match(FLOAT_NUMBER);
 			}
 		}
@@ -2507,9 +2559,9 @@ public class prog8Parser extends Parser {
 
 	public final LiteralvalueContext literalvalue() throws RecognitionException {
 		LiteralvalueContext _localctx = new LiteralvalueContext(_ctx, getState());
-		enterRule(_localctx, 76, RULE_literalvalue);
+		enterRule(_localctx, 78, RULE_literalvalue);
 		try {
-			setState(398);
+			setState(408);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case DEC_INTEGER:
@@ -2517,7 +2569,7 @@ public class prog8Parser extends Parser {
 			case BIN_INTEGER:
 				enterOuterAlt(_localctx, 1);
 				{
-				setState(392);
+				setState(402);
 				integerliteral();
 				}
 				break;
@@ -2525,35 +2577,35 @@ public class prog8Parser extends Parser {
 			case T__79:
 				enterOuterAlt(_localctx, 2);
 				{
-				setState(393);
+				setState(403);
 				booleanliteral();
 				}
 				break;
 			case T__26:
 				enterOuterAlt(_localctx, 3);
 				{
-				setState(394);
+				setState(404);
 				arrayliteral();
 				}
 				break;
 			case STRING:
 				enterOuterAlt(_localctx, 4);
 				{
-				setState(395);
+				setState(405);
 				stringliteral();
 				}
 				break;
 			case SINGLECHAR:
 				enterOuterAlt(_localctx, 5);
 				{
-				setState(396);
+				setState(406);
 				charliteral();
 				}
 				break;
 			case FLOAT_NUMBER:
 				enterOuterAlt(_localctx, 6);
 				{
-				setState(397);
+				setState(407);
 				floatliteral();
 				}
 				break;
@@ -2582,13 +2634,13 @@ public class prog8Parser extends Parser {
 
 	public final InlineasmContext inlineasm() throws RecognitionException {
 		InlineasmContext _localctx = new InlineasmContext(_ctx, getState());
-		enterRule(_localctx, 78, RULE_inlineasm);
+		enterRule(_localctx, 80, RULE_inlineasm);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(400);
+			setState(410);
 			match(T__80);
-			setState(401);
+			setState(411);
 			match(INLINEASMBLOCK);
 			}
 		}
@@ -2625,43 +2677,43 @@ public class prog8Parser extends Parser {
 
 	public final SubroutineContext subroutine() throws RecognitionException {
 		SubroutineContext _localctx = new SubroutineContext(_ctx, getState());
-		enterRule(_localctx, 80, RULE_subroutine);
+		enterRule(_localctx, 82, RULE_subroutine);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(403);
+			setState(413);
 			match(T__81);
-			setState(404);
+			setState(414);
 			identifier();
-			setState(405);
+			setState(415);
 			match(T__39);
-			setState(407);
+			setState(417);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==NAME) {
 				{
-				setState(406);
+				setState(416);
 				sub_params();
 				}
 			}
 
-			setState(409);
+			setState(419);
 			match(T__40);
-			setState(411);
+			setState(421);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==T__82) {
 				{
-				setState(410);
+				setState(420);
 				sub_return_part();
 				}
 			}
 
 			{
-			setState(413);
+			setState(423);
 			statement_block();
-			setState(414);
+			setState(424);
 			match(EOL);
 			}
 			}
@@ -2689,13 +2741,13 @@ public class prog8Parser extends Parser {
 
 	public final Sub_return_partContext sub_return_part() throws RecognitionException {
 		Sub_return_partContext _localctx = new Sub_return_partContext(_ctx, getState());
-		enterRule(_localctx, 82, RULE_sub_return_part);
+		enterRule(_localctx, 84, RULE_sub_return_part);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(416);
+			setState(426);
 			match(T__82);
-			setState(417);
+			setState(427);
 			sub_returns();
 			}
 		}
@@ -2729,21 +2781,21 @@ public class prog8Parser extends Parser {
 
 	public final Statement_blockContext statement_block() throws RecognitionException {
 		Statement_blockContext _localctx = new Statement_blockContext(_ctx, getState());
-		enterRule(_localctx, 84, RULE_statement_block);
+		enterRule(_localctx, 86, RULE_statement_block);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(419);
+			setState(429);
 			match(T__83);
-			setState(420);
+			setState(430);
 			match(EOL);
-			setState(425);
+			setState(435);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((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__12) | (1L << T__15) | (1L << T__16) | (1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25))) != 0) || ((((_la - 64)) & ~0x3f) == 0 && ((1L << (_la - 64)) & ((1L << (T__63 - 64)) | (1L << (T__64 - 64)) | (1L << (T__65 - 64)) | (1L << (T__67 - 64)) | (1L << (T__68 - 64)) | (1L << (T__69 - 64)) | (1L << (T__80 - 64)) | (1L << (T__81 - 64)) | (1L << (T__85 - 64)) | (1L << (T__88 - 64)) | (1L << (T__90 - 64)) | (1L << (T__91 - 64)) | (1L << (T__92 - 64)) | (1L << (T__93 - 64)) | (1L << (T__94 - 64)) | (1L << (T__95 - 64)) | (1L << (T__96 - 64)) | (1L << (T__97 - 64)) | (1L << (T__98 - 64)) | (1L << (T__99 - 64)) | (1L << (T__100 - 64)) | (1L << (T__101 - 64)) | (1L << (T__102 - 64)) | (1L << (T__104 - 64)) | (1L << (T__105 - 64)) | (1L << (EOL - 64)) | (1L << (NAME - 64)))) != 0)) {
 				{
-				setState(423);
+				setState(433);
 				_errHandler.sync(this);
 				switch (_input.LA(1)) {
 				case T__2:
@@ -2795,13 +2847,13 @@ public class prog8Parser extends Parser {
 				case T__105:
 				case NAME:
 					{
-					setState(421);
+					setState(431);
 					statement();
 					}
 					break;
 				case EOL:
 					{
-					setState(422);
+					setState(432);
 					match(EOL);
 					}
 					break;
@@ -2809,11 +2861,11 @@ public class prog8Parser extends Parser {
 					throw new NoViableAltException(this);
 				}
 				}
-				setState(427);
+				setState(437);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
-			setState(428);
+			setState(438);
 			match(T__84);
 			}
 		}
@@ -2847,36 +2899,36 @@ public class prog8Parser extends Parser {
 
 	public final Sub_paramsContext sub_params() throws RecognitionException {
 		Sub_paramsContext _localctx = new Sub_paramsContext(_ctx, getState());
-		enterRule(_localctx, 86, RULE_sub_params);
+		enterRule(_localctx, 88, RULE_sub_params);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(430);
+			setState(440);
 			sub_param();
-			setState(438);
+			setState(448);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(431);
+				setState(441);
 				match(T__13);
-				setState(433);
+				setState(443);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(432);
+					setState(442);
 					match(EOL);
 					}
 				}
 
-				setState(435);
+				setState(445);
 				sub_param();
 				}
 				}
-				setState(440);
+				setState(450);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -2908,15 +2960,15 @@ public class prog8Parser extends Parser {
 
 	public final Sub_paramContext sub_param() throws RecognitionException {
 		Sub_paramContext _localctx = new Sub_paramContext(_ctx, getState());
-		enterRule(_localctx, 88, RULE_sub_param);
+		enterRule(_localctx, 90, RULE_sub_param);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(441);
+			setState(451);
 			identifier();
-			setState(442);
+			setState(452);
 			match(T__1);
-			setState(443);
+			setState(453);
 			datatype();
 			}
 		}
@@ -2950,36 +3002,36 @@ public class prog8Parser extends Parser {
 
 	public final Sub_returnsContext sub_returns() throws RecognitionException {
 		Sub_returnsContext _localctx = new Sub_returnsContext(_ctx, getState());
-		enterRule(_localctx, 90, RULE_sub_returns);
+		enterRule(_localctx, 92, RULE_sub_returns);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(445);
+			setState(455);
 			datatype();
-			setState(453);
+			setState(463);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(446);
+				setState(456);
 				match(T__13);
-				setState(448);
+				setState(458);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(447);
+					setState(457);
 					match(EOL);
 					}
 				}
 
-				setState(450);
+				setState(460);
 				datatype();
 				}
 				}
-				setState(455);
+				setState(465);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -3023,75 +3075,75 @@ public class prog8Parser extends Parser {
 
 	public final AsmsubroutineContext asmsubroutine() throws RecognitionException {
 		AsmsubroutineContext _localctx = new AsmsubroutineContext(_ctx, getState());
-		enterRule(_localctx, 92, RULE_asmsubroutine);
+		enterRule(_localctx, 94, RULE_asmsubroutine);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(456);
+			setState(466);
 			match(T__85);
-			setState(457);
+			setState(467);
 			identifier();
-			setState(458);
+			setState(468);
 			match(T__39);
-			setState(460);
+			setState(470);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==NAME) {
 				{
-				setState(459);
+				setState(469);
 				asmsub_params();
 				}
 			}
 
-			setState(462);
+			setState(472);
 			match(T__40);
-			setState(463);
+			setState(473);
 			match(T__82);
-			setState(464);
+			setState(474);
 			match(T__86);
-			setState(465);
+			setState(475);
 			match(T__39);
-			setState(467);
+			setState(477);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (((((_la - 68)) & ~0x3f) == 0 && ((1L << (_la - 68)) & ((1L << (T__67 - 68)) | (1L << (T__68 - 68)) | (1L << (T__69 - 68)))) != 0)) {
 				{
-				setState(466);
+				setState(476);
 				clobber();
 				}
 			}
 
-			setState(469);
+			setState(479);
 			match(T__40);
-			setState(470);
+			setState(480);
 			match(T__82);
-			setState(471);
+			setState(481);
 			match(T__39);
-			setState(473);
+			setState(483);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25))) != 0)) {
 				{
-				setState(472);
+				setState(482);
 				asmsub_returns();
 				}
 			}
 
-			setState(475);
+			setState(485);
 			match(T__40);
-			setState(478);
+			setState(488);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__14:
 				{
-				setState(476);
+				setState(486);
 				asmsub_address();
 				}
 				break;
 			case T__83:
 				{
-				setState(477);
+				setState(487);
 				statement_block();
 				}
 				break;
@@ -3124,13 +3176,13 @@ public class prog8Parser extends Parser {
 
 	public final Asmsub_addressContext asmsub_address() throws RecognitionException {
 		Asmsub_addressContext _localctx = new Asmsub_addressContext(_ctx, getState());
-		enterRule(_localctx, 94, RULE_asmsub_address);
+		enterRule(_localctx, 96, RULE_asmsub_address);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(480);
+			setState(490);
 			match(T__14);
-			setState(481);
+			setState(491);
 			((Asmsub_addressContext)_localctx).address = integerliteral();
 			}
 		}
@@ -3164,36 +3216,36 @@ public class prog8Parser extends Parser {
 
 	public final Asmsub_paramsContext asmsub_params() throws RecognitionException {
 		Asmsub_paramsContext _localctx = new Asmsub_paramsContext(_ctx, getState());
-		enterRule(_localctx, 96, RULE_asmsub_params);
+		enterRule(_localctx, 98, RULE_asmsub_params);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(483);
+			setState(493);
 			asmsub_param();
-			setState(491);
+			setState(501);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(484);
+				setState(494);
 				match(T__13);
-				setState(486);
+				setState(496);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(485);
+					setState(495);
 					match(EOL);
 					}
 				}
 
-				setState(488);
+				setState(498);
 				asmsub_param();
 				}
 				}
-				setState(493);
+				setState(503);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -3231,19 +3283,19 @@ public class prog8Parser extends Parser {
 
 	public final Asmsub_paramContext asmsub_param() throws RecognitionException {
 		Asmsub_paramContext _localctx = new Asmsub_paramContext(_ctx, getState());
-		enterRule(_localctx, 98, RULE_asmsub_param);
+		enterRule(_localctx, 100, RULE_asmsub_param);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(494);
+			setState(504);
 			identifier();
-			setState(495);
+			setState(505);
 			match(T__1);
-			setState(496);
+			setState(506);
 			datatype();
-			setState(497);
+			setState(507);
 			match(T__87);
-			setState(500);
+			setState(510);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__67:
@@ -3253,7 +3305,7 @@ public class prog8Parser extends Parser {
 			case T__71:
 			case T__72:
 				{
-				setState(498);
+				setState(508);
 				registerorpair();
 				}
 				break;
@@ -3262,7 +3314,7 @@ public class prog8Parser extends Parser {
 			case T__75:
 			case T__76:
 				{
-				setState(499);
+				setState(509);
 				statusregister();
 				}
 				break;
@@ -3297,26 +3349,26 @@ public class prog8Parser extends Parser {
 
 	public final ClobberContext clobber() throws RecognitionException {
 		ClobberContext _localctx = new ClobberContext(_ctx, getState());
-		enterRule(_localctx, 100, RULE_clobber);
+		enterRule(_localctx, 102, RULE_clobber);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(502);
+			setState(512);
 			register();
-			setState(507);
+			setState(517);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(503);
+				setState(513);
 				match(T__13);
-				setState(504);
+				setState(514);
 				register();
 				}
 				}
-				setState(509);
+				setState(519);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -3352,36 +3404,36 @@ public class prog8Parser extends Parser {
 
 	public final Asmsub_returnsContext asmsub_returns() throws RecognitionException {
 		Asmsub_returnsContext _localctx = new Asmsub_returnsContext(_ctx, getState());
-		enterRule(_localctx, 102, RULE_asmsub_returns);
+		enterRule(_localctx, 104, RULE_asmsub_returns);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(510);
+			setState(520);
 			asmsub_return();
-			setState(518);
+			setState(528);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			while (_la==T__13) {
 				{
 				{
-				setState(511);
+				setState(521);
 				match(T__13);
-				setState(513);
+				setState(523);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 				if (_la==EOL) {
 					{
-					setState(512);
+					setState(522);
 					match(EOL);
 					}
 				}
 
-				setState(515);
+				setState(525);
 				asmsub_return();
 				}
 				}
-				setState(520);
+				setState(530);
 				_errHandler.sync(this);
 				_la = _input.LA(1);
 			}
@@ -3416,15 +3468,15 @@ public class prog8Parser extends Parser {
 
 	public final Asmsub_returnContext asmsub_return() throws RecognitionException {
 		Asmsub_returnContext _localctx = new Asmsub_returnContext(_ctx, getState());
-		enterRule(_localctx, 104, RULE_asmsub_return);
+		enterRule(_localctx, 106, RULE_asmsub_return);
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(521);
+			setState(531);
 			datatype();
-			setState(522);
+			setState(532);
 			match(T__87);
-			setState(525);
+			setState(535);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__67:
@@ -3434,7 +3486,7 @@ public class prog8Parser extends Parser {
 			case T__71:
 			case T__72:
 				{
-				setState(523);
+				setState(533);
 				registerorpair();
 				}
 				break;
@@ -3443,7 +3495,7 @@ public class prog8Parser extends Parser {
 			case T__75:
 			case T__76:
 				{
-				setState(524);
+				setState(534);
 				statusregister();
 				}
 				break;
@@ -3488,26 +3540,26 @@ public class prog8Parser extends Parser {
 
 	public final If_stmtContext if_stmt() throws RecognitionException {
 		If_stmtContext _localctx = new If_stmtContext(_ctx, getState());
-		enterRule(_localctx, 106, RULE_if_stmt);
+		enterRule(_localctx, 108, RULE_if_stmt);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(527);
+			setState(537);
 			match(T__88);
-			setState(528);
+			setState(538);
 			expression(0);
-			setState(530);
+			setState(540);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(529);
+				setState(539);
 				match(EOL);
 				}
 			}
 
-			setState(534);
+			setState(544);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__2:
@@ -3559,40 +3611,40 @@ public class prog8Parser extends Parser {
 			case T__105:
 			case NAME:
 				{
-				setState(532);
+				setState(542);
 				statement();
 				}
 				break;
 			case T__83:
 				{
-				setState(533);
+				setState(543);
 				statement_block();
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
-			setState(537);
+			setState(547);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,53,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,54,_ctx) ) {
 			case 1:
 				{
-				setState(536);
+				setState(546);
 				match(EOL);
 				}
 				break;
 			}
-			setState(540);
+			setState(550);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==T__89) {
 				{
-				setState(539);
+				setState(549);
 				else_part();
 				}
 			}
 
-			setState(542);
+			setState(552);
 			match(EOL);
 			}
 		}
@@ -3623,24 +3675,24 @@ public class prog8Parser extends Parser {
 
 	public final Else_partContext else_part() throws RecognitionException {
 		Else_partContext _localctx = new Else_partContext(_ctx, getState());
-		enterRule(_localctx, 108, RULE_else_part);
+		enterRule(_localctx, 110, RULE_else_part);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(544);
+			setState(554);
 			match(T__89);
-			setState(546);
+			setState(556);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(545);
+				setState(555);
 				match(EOL);
 				}
 			}
 
-			setState(550);
+			setState(560);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__2:
@@ -3692,13 +3744,13 @@ public class prog8Parser extends Parser {
 			case T__105:
 			case NAME:
 				{
-				setState(548);
+				setState(558);
 				statement();
 				}
 				break;
 			case T__83:
 				{
-				setState(549);
+				setState(559);
 				statement_block();
 				}
 				break;
@@ -3743,24 +3795,24 @@ public class prog8Parser extends Parser {
 
 	public final Branch_stmtContext branch_stmt() throws RecognitionException {
 		Branch_stmtContext _localctx = new Branch_stmtContext(_ctx, getState());
-		enterRule(_localctx, 110, RULE_branch_stmt);
+		enterRule(_localctx, 112, RULE_branch_stmt);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(552);
+			setState(562);
 			branchcondition();
-			setState(554);
+			setState(564);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(553);
+				setState(563);
 				match(EOL);
 				}
 			}
 
-			setState(558);
+			setState(568);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__2:
@@ -3812,40 +3864,40 @@ public class prog8Parser extends Parser {
 			case T__105:
 			case NAME:
 				{
-				setState(556);
+				setState(566);
 				statement();
 				}
 				break;
 			case T__83:
 				{
-				setState(557);
+				setState(567);
 				statement_block();
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
-			setState(561);
+			setState(571);
 			_errHandler.sync(this);
-			switch ( getInterpreter().adaptivePredict(_input,59,_ctx) ) {
+			switch ( getInterpreter().adaptivePredict(_input,60,_ctx) ) {
 			case 1:
 				{
-				setState(560);
+				setState(570);
 				match(EOL);
 				}
 				break;
 			}
-			setState(564);
+			setState(574);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==T__89) {
 				{
-				setState(563);
+				setState(573);
 				else_part();
 				}
 			}
 
-			setState(566);
+			setState(576);
 			match(EOL);
 			}
 		}
@@ -3869,12 +3921,12 @@ public class prog8Parser extends Parser {
 
 	public final BranchconditionContext branchcondition() throws RecognitionException {
 		BranchconditionContext _localctx = new BranchconditionContext(_ctx, getState());
-		enterRule(_localctx, 112, RULE_branchcondition);
+		enterRule(_localctx, 114, RULE_branchcondition);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(568);
+			setState(578);
 			_la = _input.LA(1);
 			if ( !(((((_la - 91)) & ~0x3f) == 0 && ((1L << (_la - 91)) & ((1L << (T__90 - 91)) | (1L << (T__91 - 91)) | (1L << (T__92 - 91)) | (1L << (T__93 - 91)) | (1L << (T__94 - 91)) | (1L << (T__95 - 91)) | (1L << (T__96 - 91)) | (1L << (T__97 - 91)) | (1L << (T__98 - 91)) | (1L << (T__99 - 91)) | (1L << (T__100 - 91)) | (1L << (T__101 - 91)))) != 0)) ) {
 			_errHandler.recoverInline(this);
@@ -3922,58 +3974,58 @@ public class prog8Parser extends Parser {
 
 	public final ForloopContext forloop() throws RecognitionException {
 		ForloopContext _localctx = new ForloopContext(_ctx, getState());
-		enterRule(_localctx, 114, RULE_forloop);
+		enterRule(_localctx, 116, RULE_forloop);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(570);
+			setState(580);
 			match(T__102);
-			setState(572);
+			setState(582);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__17) | (1L << T__18) | (1L << T__19) | (1L << T__20) | (1L << T__21) | (1L << T__22) | (1L << T__23) | (1L << T__24) | (1L << T__25))) != 0)) {
 				{
-				setState(571);
+				setState(581);
 				datatype();
 				}
 			}
 
-			setState(576);
+			setState(586);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__67:
 			case T__68:
 			case T__69:
 				{
-				setState(574);
+				setState(584);
 				register();
 				}
 				break;
 			case NAME:
 				{
-				setState(575);
+				setState(585);
 				identifier();
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
-			setState(578);
+			setState(588);
 			match(T__103);
-			setState(579);
+			setState(589);
 			expression(0);
-			setState(581);
+			setState(591);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(580);
+				setState(590);
 				match(EOL);
 				}
 			}
 
-			setState(583);
+			setState(593);
 			statement_block();
 			}
 		}
@@ -4007,26 +4059,26 @@ public class prog8Parser extends Parser {
 
 	public final WhileloopContext whileloop() throws RecognitionException {
 		WhileloopContext _localctx = new WhileloopContext(_ctx, getState());
-		enterRule(_localctx, 116, RULE_whileloop);
+		enterRule(_localctx, 118, RULE_whileloop);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(585);
+			setState(595);
 			match(T__104);
-			setState(586);
+			setState(596);
 			expression(0);
-			setState(588);
+			setState(598);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(587);
+				setState(597);
 				match(EOL);
 				}
 			}
 
-			setState(592);
+			setState(602);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__2:
@@ -4078,13 +4130,13 @@ public class prog8Parser extends Parser {
 			case T__105:
 			case NAME:
 				{
-				setState(590);
+				setState(600);
 				statement();
 				}
 				break;
 			case T__83:
 				{
-				setState(591);
+				setState(601);
 				statement_block();
 				}
 				break;
@@ -4123,14 +4175,14 @@ public class prog8Parser extends Parser {
 
 	public final RepeatloopContext repeatloop() throws RecognitionException {
 		RepeatloopContext _localctx = new RepeatloopContext(_ctx, getState());
-		enterRule(_localctx, 118, RULE_repeatloop);
+		enterRule(_localctx, 120, RULE_repeatloop);
 		int _la;
 		try {
 			enterOuterAlt(_localctx, 1);
 			{
-			setState(594);
+			setState(604);
 			match(T__105);
-			setState(597);
+			setState(607);
 			_errHandler.sync(this);
 			switch (_input.LA(1)) {
 			case T__2:
@@ -4182,32 +4234,32 @@ public class prog8Parser extends Parser {
 			case T__105:
 			case NAME:
 				{
-				setState(595);
+				setState(605);
 				statement();
 				}
 				break;
 			case T__83:
 				{
-				setState(596);
+				setState(606);
 				statement_block();
 				}
 				break;
 			default:
 				throw new NoViableAltException(this);
 			}
-			setState(600);
+			setState(610);
 			_errHandler.sync(this);
 			_la = _input.LA(1);
 			if (_la==EOL) {
 				{
-				setState(599);
+				setState(609);
 				match(EOL);
 				}
 			}
 
-			setState(602);
+			setState(612);
 			match(T__106);
-			setState(603);
+			setState(613);
 			expression(0);
 			}
 		}
@@ -4224,7 +4276,7 @@ public class prog8Parser extends Parser {
 
 	public boolean sempred(RuleContext _localctx, int ruleIndex, int predIndex) {
 		switch (ruleIndex) {
-		case 18:
+		case 19:
 			return expression_sempred((ExpressionContext)_localctx, predIndex);
 		}
 		return true;
@@ -4260,7 +4312,7 @@ public class prog8Parser extends Parser {
 	}
 
 	public static final String _serializedATN =
-		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3y\u0260\4\2\t\2\4"+
+		"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3y\u026a\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"+
@@ -4268,228 +4320,232 @@ public class prog8Parser extends Parser {
 		"\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="+
-		"\3\2\3\2\7\2}\n\2\f\2\16\2\u0080\13\2\3\2\3\2\3\3\3\3\5\3\u0086\n\3\3"+
-		"\4\3\4\3\4\5\4\u008b\n\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\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00a6\n\5\3"+
-		"\6\3\6\3\6\3\7\3\7\3\7\3\7\5\7\u00af\n\7\3\b\3\b\5\b\u00b3\n\b\3\b\3\b"+
-		"\3\b\7\b\u00b8\n\b\f\b\16\b\u00bb\13\b\5\b\u00bd\n\b\3\t\3\t\3\t\5\t\u00c2"+
-		"\n\t\3\n\3\n\5\n\u00c6\n\n\3\n\3\n\3\13\3\13\5\13\u00cc\n\13\3\13\3\13"+
-		"\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17\3\17\3\20"+
-		"\3\20\3\20\3\20\3\21\3\21\3\21\3\21\3\22\3\22\3\22\3\22\5\22\u00ea\n\22"+
-		"\3\23\3\23\3\23\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24"+
-		"\3\24\3\24\3\24\3\24\5\24\u00fe\n\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24"+
-		"\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24"+
-		"\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24\3\24"+
-		"\3\24\3\24\3\24\5\24\u0126\n\24\7\24\u0128\n\24\f\24\16\24\u012b\13\24"+
-		"\3\25\3\25\5\25\u012f\n\25\3\25\3\25\3\26\3\26\5\26\u0135\n\26\3\26\3"+
-		"\26\5\26\u0139\n\26\3\26\3\26\3\27\3\27\5\27\u013f\n\27\3\27\3\27\5\27"+
-		"\u0143\n\27\3\27\3\27\3\30\3\30\3\30\5\30\u014a\n\30\3\30\7\30\u014d\n"+
-		"\30\f\30\16\30\u0150\13\30\3\31\3\31\5\31\u0154\n\31\3\32\3\32\3\33\3"+
-		"\33\3\34\3\34\3\35\3\35\3\35\6\35\u015f\n\35\r\35\16\35\u0160\3\36\3\36"+
-		"\3\37\3\37\3 \3 \3!\3!\5!\u016b\n!\3\"\3\"\3#\3#\3$\3$\5$\u0173\n$\3$"+
-		"\3$\3$\5$\u0178\n$\3$\7$\u017b\n$\f$\16$\u017e\13$\3$\5$\u0181\n$\3$\3"+
-		"$\3%\3%\3&\3&\3\'\3\'\3(\3(\3(\3(\3(\3(\5(\u0191\n(\3)\3)\3)\3*\3*\3*"+
-		"\3*\5*\u019a\n*\3*\3*\5*\u019e\n*\3*\3*\3*\3+\3+\3+\3,\3,\3,\3,\7,\u01aa"+
-		"\n,\f,\16,\u01ad\13,\3,\3,\3-\3-\3-\5-\u01b4\n-\3-\7-\u01b7\n-\f-\16-"+
-		"\u01ba\13-\3.\3.\3.\3.\3/\3/\3/\5/\u01c3\n/\3/\7/\u01c6\n/\f/\16/\u01c9"+
-		"\13/\3\60\3\60\3\60\3\60\5\60\u01cf\n\60\3\60\3\60\3\60\3\60\3\60\5\60"+
-		"\u01d6\n\60\3\60\3\60\3\60\3\60\5\60\u01dc\n\60\3\60\3\60\3\60\5\60\u01e1"+
-		"\n\60\3\61\3\61\3\61\3\62\3\62\3\62\5\62\u01e9\n\62\3\62\7\62\u01ec\n"+
-		"\62\f\62\16\62\u01ef\13\62\3\63\3\63\3\63\3\63\3\63\3\63\5\63\u01f7\n"+
-		"\63\3\64\3\64\3\64\7\64\u01fc\n\64\f\64\16\64\u01ff\13\64\3\65\3\65\3"+
-		"\65\5\65\u0204\n\65\3\65\7\65\u0207\n\65\f\65\16\65\u020a\13\65\3\66\3"+
-		"\66\3\66\3\66\5\66\u0210\n\66\3\67\3\67\3\67\5\67\u0215\n\67\3\67\3\67"+
-		"\5\67\u0219\n\67\3\67\5\67\u021c\n\67\3\67\5\67\u021f\n\67\3\67\3\67\3"+
-		"8\38\58\u0225\n8\38\38\58\u0229\n8\39\39\59\u022d\n9\39\39\59\u0231\n"+
-		"9\39\59\u0234\n9\39\59\u0237\n9\39\39\3:\3:\3;\3;\5;\u023f\n;\3;\3;\5"+
-		";\u0243\n;\3;\3;\3;\5;\u0248\n;\3;\3;\3<\3<\3<\5<\u024f\n<\3<\3<\5<\u0253"+
-		"\n<\3=\3=\3=\5=\u0258\n=\3=\5=\u025b\n=\3=\3=\3=\3=\2\3&>\2\4\6\b\n\f"+
-		"\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^"+
-		"`bdfhjlnprtvx\2\21\3\2\6\17\3\2\24\34\3\2\37\'\3\2()\4\2\3\3,-\3\2/\62"+
-		"\3\2,-\3\2\63\66\3\2\678\3\2FH\3\2FK\3\2LO\3\2su\3\2QR\3\2]h\2\u0294\2"+
-		"~\3\2\2\2\4\u0085\3\2\2\2\6\u0087\3\2\2\2\b\u00a5\3\2\2\2\n\u00a7\3\2"+
-		"\2\2\f\u00aa\3\2\2\2\16\u00b0\3\2\2\2\20\u00c1\3\2\2\2\22\u00c3\3\2\2"+
-		"\2\24\u00c9\3\2\2\2\26\u00d1\3\2\2\2\30\u00d4\3\2\2\2\32\u00d7\3\2\2\2"+
-		"\34\u00d9\3\2\2\2\36\u00dd\3\2\2\2 \u00e1\3\2\2\2\"\u00e9\3\2\2\2$\u00eb"+
-		"\3\2\2\2&\u00fd\3\2\2\2(\u012e\3\2\2\2*\u0134\3\2\2\2,\u013e\3\2\2\2."+
-		"\u0146\3\2\2\2\60\u0151\3\2\2\2\62\u0155\3\2\2\2\64\u0157\3\2\2\2\66\u0159"+
-		"\3\2\2\28\u015b\3\2\2\2:\u0162\3\2\2\2<\u0164\3\2\2\2>\u0166\3\2\2\2@"+
-		"\u0168\3\2\2\2B\u016c\3\2\2\2D\u016e\3\2\2\2F\u0170\3\2\2\2H\u0184\3\2"+
-		"\2\2J\u0186\3\2\2\2L\u0188\3\2\2\2N\u0190\3\2\2\2P\u0192\3\2\2\2R\u0195"+
-		"\3\2\2\2T\u01a2\3\2\2\2V\u01a5\3\2\2\2X\u01b0\3\2\2\2Z\u01bb\3\2\2\2\\"+
-		"\u01bf\3\2\2\2^\u01ca\3\2\2\2`\u01e2\3\2\2\2b\u01e5\3\2\2\2d\u01f0\3\2"+
-		"\2\2f\u01f8\3\2\2\2h\u0200\3\2\2\2j\u020b\3\2\2\2l\u0211\3\2\2\2n\u0222"+
-		"\3\2\2\2p\u022a\3\2\2\2r\u023a\3\2\2\2t\u023c\3\2\2\2v\u024b\3\2\2\2x"+
-		"\u0254\3\2\2\2z}\5\4\3\2{}\7q\2\2|z\3\2\2\2|{\3\2\2\2}\u0080\3\2\2\2~"+
-		"|\3\2\2\2~\177\3\2\2\2\177\u0081\3\2\2\2\u0080~\3\2\2\2\u0081\u0082\7"+
-		"\2\2\3\u0082\3\3\2\2\2\u0083\u0086\5\16\b\2\u0084\u0086\5\6\4\2\u0085"+
-		"\u0083\3\2\2\2\u0085\u0084\3\2\2\2\u0086\5\3\2\2\2\u0087\u0088\7\3\2\2"+
-		"\u0088\u008a\5\66\34\2\u0089\u008b\5@!\2\u008a\u0089\3\2\2\2\u008a\u008b"+
-		"\3\2\2\2\u008b\u008c\3\2\2\2\u008c\u008d\5V,\2\u008d\u008e\7q\2\2\u008e"+
-		"\7\3\2\2\2\u008f\u00a6\5\16\b\2\u0090\u00a6\5\24\13\2\u0091\u00a6\5\22"+
-		"\n\2\u0092\u00a6\5\26\f\2\u0093\u00a6\5\30\r\2\u0094\u00a6\5\36\20\2\u0095"+
-		"\u00a6\5 \21\2\u0096\u00a6\5\f\7\2\u0097\u00a6\5$\23\2\u0098\u00a6\5,"+
-		"\27\2\u0099\u00a6\5l\67\2\u009a\u00a6\5p9\2\u009b\u00a6\5R*\2\u009c\u00a6"+
-		"\5^\60\2\u009d\u00a6\5P)\2\u009e\u00a6\5\60\31\2\u009f\u00a6\5t;\2\u00a0"+
-		"\u00a6\5v<\2\u00a1\u00a6\5x=\2\u00a2\u00a6\5\62\32\2\u00a3\u00a6\5\64"+
-		"\33\2\u00a4\u00a6\5\n\6\2\u00a5\u008f\3\2\2\2\u00a5\u0090\3\2\2\2\u00a5"+
-		"\u0091\3\2\2\2\u00a5\u0092\3\2\2\2\u00a5\u0093\3\2\2\2\u00a5\u0094\3\2"+
-		"\2\2\u00a5\u0095\3\2\2\2\u00a5\u0096\3\2\2\2\u00a5\u0097\3\2\2\2\u00a5"+
-		"\u0098\3\2\2\2\u00a5\u0099\3\2\2\2\u00a5\u009a\3\2\2\2\u00a5\u009b\3\2"+
-		"\2\2\u00a5\u009c\3\2\2\2\u00a5\u009d\3\2\2\2\u00a5\u009e\3\2\2\2\u00a5"+
-		"\u009f\3\2\2\2\u00a5\u00a0\3\2\2\2\u00a5\u00a1\3\2\2\2\u00a5\u00a2\3\2"+
-		"\2\2\u00a5\u00a3\3\2\2\2\u00a5\u00a4\3\2\2\2\u00a6\t\3\2\2\2\u00a7\u00a8"+
-		"\5\66\34\2\u00a8\u00a9\7\4\2\2\u00a9\13\3\2\2\2\u00aa\u00ae\7\5\2\2\u00ab"+
-		"\u00af\5@!\2\u00ac\u00af\5\66\34\2\u00ad\u00af\58\35\2\u00ae\u00ab\3\2"+
-		"\2\2\u00ae\u00ac\3\2\2\2\u00ae\u00ad\3\2\2\2\u00af\r\3\2\2\2\u00b0\u00bc"+
-		"\t\2\2\2\u00b1\u00b3\5\20\t\2\u00b2\u00b1\3\2\2\2\u00b2\u00b3\3\2\2\2"+
-		"\u00b3\u00bd\3\2\2\2\u00b4\u00b9\5\20\t\2\u00b5\u00b6\7\20\2\2\u00b6\u00b8"+
-		"\5\20\t\2\u00b7\u00b5\3\2\2\2\u00b8\u00bb\3\2\2\2\u00b9\u00b7\3\2\2\2"+
-		"\u00b9\u00ba\3\2\2\2\u00ba\u00bd\3\2\2\2\u00bb\u00b9\3\2\2\2\u00bc\u00b2"+
-		"\3\2\2\2\u00bc\u00b4\3\2\2\2\u00bd\17\3\2\2\2\u00be\u00c2\5H%\2\u00bf"+
-		"\u00c2\5\66\34\2\u00c0\u00c2\5@!\2\u00c1\u00be\3\2\2\2\u00c1\u00bf\3\2"+
-		"\2\2\u00c1\u00c0\3\2\2\2\u00c2\21\3\2\2\2\u00c3\u00c5\5\32\16\2\u00c4"+
-		"\u00c6\5\34\17\2\u00c5\u00c4\3\2\2\2\u00c5\u00c6\3\2\2\2\u00c6\u00c7\3"+
-		"\2\2\2\u00c7\u00c8\5\66\34\2\u00c8\23\3\2\2\2\u00c9\u00cb\5\32\16\2\u00ca"+
-		"\u00cc\5\34\17\2\u00cb\u00ca\3\2\2\2\u00cb\u00cc\3\2\2\2\u00cc\u00cd\3"+
-		"\2\2\2\u00cd\u00ce\5\66\34\2\u00ce\u00cf\7\21\2\2\u00cf\u00d0\5&\24\2"+
-		"\u00d0\25\3\2\2\2\u00d1\u00d2\7\22\2\2\u00d2\u00d3\5\24\13\2\u00d3\27"+
-		"\3\2\2\2\u00d4\u00d5\7\23\2\2\u00d5\u00d6\5\24\13\2\u00d6\31\3\2\2\2\u00d7"+
-		"\u00d8\t\3\2\2\u00d8\33\3\2\2\2\u00d9\u00da\7\35\2\2\u00da\u00db\5&\24"+
-		"\2\u00db\u00dc\7\36\2\2\u00dc\35\3\2\2\2\u00dd\u00de\5\"\22\2\u00de\u00df"+
-		"\7\21\2\2\u00df\u00e0\5&\24\2\u00e0\37\3\2\2\2\u00e1\u00e2\5\"\22\2\u00e2"+
-		"\u00e3\t\4\2\2\u00e3\u00e4\5&\24\2\u00e4!\3\2\2\2\u00e5\u00ea\5:\36\2"+
-		"\u00e6\u00ea\5\66\34\2\u00e7\u00ea\58\35\2\u00e8\u00ea\5(\25\2\u00e9\u00e5"+
-		"\3\2\2\2\u00e9\u00e6\3\2\2\2\u00e9\u00e7\3\2\2\2\u00e9\u00e8\3\2\2\2\u00ea"+
-		"#\3\2\2\2\u00eb\u00ec\5\"\22\2\u00ec\u00ed\t\5\2\2\u00ed%\3\2\2\2\u00ee"+
-		"\u00ef\b\24\1\2\u00ef\u00f0\7*\2\2\u00f0\u00f1\5&\24\2\u00f1\u00f2\7+"+
-		"\2\2\u00f2\u00fe\3\2\2\2\u00f3\u00fe\5*\26\2\u00f4\u00f5\t\6\2\2\u00f5"+
-		"\u00fe\5&\24\25\u00f6\u00f7\7A\2\2\u00f7\u00fe\5&\24\b\u00f8\u00fe\5N"+
-		"(\2\u00f9\u00fe\5:\36\2\u00fa\u00fe\5\66\34\2\u00fb\u00fe\58\35\2\u00fc"+
-		"\u00fe\5(\25\2\u00fd\u00ee\3\2\2\2\u00fd\u00f3\3\2\2\2\u00fd\u00f4\3\2"+
-		"\2\2\u00fd\u00f6\3\2\2\2\u00fd\u00f8\3\2\2\2\u00fd\u00f9\3\2\2\2\u00fd"+
-		"\u00fa\3\2\2\2\u00fd\u00fb\3\2\2\2\u00fd\u00fc\3\2\2\2\u00fe\u0129\3\2"+
-		"\2\2\u00ff\u0100\f\24\2\2\u0100\u0101\7.\2\2\u0101\u0128\5&\24\25\u0102"+
-		"\u0103\f\23\2\2\u0103\u0104\t\7\2\2\u0104\u0128\5&\24\24\u0105\u0106\f"+
-		"\22\2\2\u0106\u0107\t\b\2\2\u0107\u0128\5&\24\23\u0108\u0109\f\21\2\2"+
-		"\u0109\u010a\t\t\2\2\u010a\u0128\5&\24\22\u010b\u010c\f\20\2\2\u010c\u010d"+
-		"\t\n\2\2\u010d\u0128\5&\24\21\u010e\u010f\f\17\2\2\u010f\u0110\79\2\2"+
-		"\u0110\u0128\5&\24\20\u0111\u0112\f\16\2\2\u0112\u0113\7:\2\2\u0113\u0128"+
-		"\5&\24\17\u0114\u0115\f\r\2\2\u0115\u0116\7;\2\2\u0116\u0128\5&\24\16"+
-		"\u0117\u0118\f\13\2\2\u0118\u0119\7>\2\2\u0119\u0128\5&\24\f\u011a\u011b"+
-		"\f\n\2\2\u011b\u011c\7?\2\2\u011c\u0128\5&\24\13\u011d\u011e\f\t\2\2\u011e"+
-		"\u011f\7@\2\2\u011f\u0128\5&\24\n\u0120\u0121\f\f\2\2\u0121\u0122\7<\2"+
-		"\2\u0122\u0125\5&\24\2\u0123\u0124\7=\2\2\u0124\u0126\5&\24\2\u0125\u0123"+
-		"\3\2\2\2\u0125\u0126\3\2\2\2\u0126\u0128\3\2\2\2\u0127\u00ff\3\2\2\2\u0127"+
-		"\u0102\3\2\2\2\u0127\u0105\3\2\2\2\u0127\u0108\3\2\2\2\u0127\u010b\3\2"+
-		"\2\2\u0127\u010e\3\2\2\2\u0127\u0111\3\2\2\2\u0127\u0114\3\2\2\2\u0127"+
-		"\u0117\3\2\2\2\u0127\u011a\3\2\2\2\u0127\u011d\3\2\2\2\u0127\u0120\3\2"+
-		"\2\2\u0128\u012b\3\2\2\2\u0129\u0127\3\2\2\2\u0129\u012a\3\2\2\2\u012a"+
-		"\'\3\2\2\2\u012b\u0129\3\2\2\2\u012c\u012f\5\66\34\2\u012d\u012f\58\35"+
-		"\2\u012e\u012c\3\2\2\2\u012e\u012d\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131"+
-		"\5\34\17\2\u0131)\3\2\2\2\u0132\u0135\5\66\34\2\u0133\u0135\58\35\2\u0134"+
-		"\u0132\3\2\2\2\u0134\u0133\3\2\2\2\u0135\u0136\3\2\2\2\u0136\u0138\7*"+
-		"\2\2\u0137\u0139\5.\30\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139"+
-		"\u013a\3\2\2\2\u013a\u013b\7+\2\2\u013b+\3\2\2\2\u013c\u013f\5\66\34\2"+
-		"\u013d\u013f\58\35\2\u013e\u013c\3\2\2\2\u013e\u013d\3\2\2\2\u013f\u0140"+
-		"\3\2\2\2\u0140\u0142\7*\2\2\u0141\u0143\5.\30\2\u0142\u0141\3\2\2\2\u0142"+
-		"\u0143\3\2\2\2\u0143\u0144\3\2\2\2\u0144\u0145\7+\2\2\u0145-\3\2\2\2\u0146"+
-		"\u014e\5&\24\2\u0147\u0149\7\20\2\2\u0148\u014a\7q\2\2\u0149\u0148\3\2"+
-		"\2\2\u0149\u014a\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u014d\5&\24\2\u014c"+
-		"\u0147\3\2\2\2\u014d\u0150\3\2\2\2\u014e\u014c\3\2\2\2\u014e\u014f\3\2"+
-		"\2\2\u014f/\3\2\2\2\u0150\u014e\3\2\2\2\u0151\u0153\7B\2\2\u0152\u0154"+
-		"\5.\30\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2\u0154\61\3\2\2\2\u0155"+
-		"\u0156\7C\2\2\u0156\63\3\2\2\2\u0157\u0158\7D\2\2\u0158\65\3\2\2\2\u0159"+
-		"\u015a\7r\2\2\u015a\67\3\2\2\2\u015b\u015e\7r\2\2\u015c\u015d\7E\2\2\u015d"+
-		"\u015f\7r\2\2\u015e\u015c\3\2\2\2\u015f\u0160\3\2\2\2\u0160\u015e\3\2"+
-		"\2\2\u0160\u0161\3\2\2\2\u01619\3\2\2\2\u0162\u0163\t\13\2\2\u0163;\3"+
-		"\2\2\2\u0164\u0165\t\f\2\2\u0165=\3\2\2\2\u0166\u0167\t\r\2\2\u0167?\3"+
-		"\2\2\2\u0168\u016a\t\16\2\2\u0169\u016b\5B\"\2\u016a\u0169\3\2\2\2\u016a"+
-		"\u016b\3\2\2\2\u016bA\3\2\2\2\u016c\u016d\7P\2\2\u016dC\3\2\2\2\u016e"+
-		"\u016f\t\17\2\2\u016fE\3\2\2\2\u0170\u0172\7\35\2\2\u0171\u0173\7q\2\2"+
-		"\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u017c"+
-		"\5&\24\2\u0175\u0177\7\20\2\2\u0176\u0178\7q\2\2\u0177\u0176\3\2\2\2\u0177"+
-		"\u0178\3\2\2\2\u0178\u0179\3\2\2\2\u0179\u017b\5&\24\2\u017a\u0175\3\2"+
-		"\2\2\u017b\u017e\3\2\2\2\u017c\u017a\3\2\2\2\u017c\u017d\3\2\2\2\u017d"+
-		"\u0180\3\2\2\2\u017e\u017c\3\2\2\2\u017f\u0181\7q\2\2\u0180\u017f\3\2"+
-		"\2\2\u0180\u0181\3\2\2\2\u0181\u0182\3\2\2\2\u0182\u0183\7\36\2\2\u0183"+
-		"G\3\2\2\2\u0184\u0185\7w\2\2\u0185I\3\2\2\2\u0186\u0187\7y\2\2\u0187K"+
-		"\3\2\2\2\u0188\u0189\7v\2\2\u0189M\3\2\2\2\u018a\u0191\5@!\2\u018b\u0191"+
-		"\5D#\2\u018c\u0191\5F$\2\u018d\u0191\5H%\2\u018e\u0191\5J&\2\u018f\u0191"+
-		"\5L\'\2\u0190\u018a\3\2\2\2\u0190\u018b\3\2\2\2\u0190\u018c\3\2\2\2\u0190"+
-		"\u018d\3\2\2\2\u0190\u018e\3\2\2\2\u0190\u018f\3\2\2\2\u0191O\3\2\2\2"+
-		"\u0192\u0193\7S\2\2\u0193\u0194\7x\2\2\u0194Q\3\2\2\2\u0195\u0196\7T\2"+
-		"\2\u0196\u0197\5\66\34\2\u0197\u0199\7*\2\2\u0198\u019a\5X-\2\u0199\u0198"+
-		"\3\2\2\2\u0199\u019a\3\2\2\2\u019a\u019b\3\2\2\2\u019b\u019d\7+\2\2\u019c"+
-		"\u019e\5T+\2\u019d\u019c\3\2\2\2\u019d\u019e\3\2\2\2\u019e\u019f\3\2\2"+
-		"\2\u019f\u01a0\5V,\2\u01a0\u01a1\7q\2\2\u01a1S\3\2\2\2\u01a2\u01a3\7U"+
-		"\2\2\u01a3\u01a4\5\\/\2\u01a4U\3\2\2\2\u01a5\u01a6\7V\2\2\u01a6\u01ab"+
-		"\7q\2\2\u01a7\u01aa\5\b\5\2\u01a8\u01aa\7q\2\2\u01a9\u01a7\3\2\2\2\u01a9"+
-		"\u01a8\3\2\2\2\u01aa\u01ad\3\2\2\2\u01ab\u01a9\3\2\2\2\u01ab\u01ac\3\2"+
-		"\2\2\u01ac\u01ae\3\2\2\2\u01ad\u01ab\3\2\2\2\u01ae\u01af\7W\2\2\u01af"+
-		"W\3\2\2\2\u01b0\u01b8\5Z.\2\u01b1\u01b3\7\20\2\2\u01b2\u01b4\7q\2\2\u01b3"+
-		"\u01b2\3\2\2\2\u01b3\u01b4\3\2\2\2\u01b4\u01b5\3\2\2\2\u01b5\u01b7\5Z"+
-		".\2\u01b6\u01b1\3\2\2\2\u01b7\u01ba\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b8"+
-		"\u01b9\3\2\2\2\u01b9Y\3\2\2\2\u01ba\u01b8\3\2\2\2\u01bb\u01bc\5\66\34"+
-		"\2\u01bc\u01bd\7\4\2\2\u01bd\u01be\5\32\16\2\u01be[\3\2\2\2\u01bf\u01c7"+
-		"\5\32\16\2\u01c0\u01c2\7\20\2\2\u01c1\u01c3\7q\2\2\u01c2\u01c1\3\2\2\2"+
-		"\u01c2\u01c3\3\2\2\2\u01c3\u01c4\3\2\2\2\u01c4\u01c6\5\32\16\2\u01c5\u01c0"+
-		"\3\2\2\2\u01c6\u01c9\3\2\2\2\u01c7\u01c5\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8"+
-		"]\3\2\2\2\u01c9\u01c7\3\2\2\2\u01ca\u01cb\7X\2\2\u01cb\u01cc\5\66\34\2"+
-		"\u01cc\u01ce\7*\2\2\u01cd\u01cf\5b\62\2\u01ce\u01cd\3\2\2\2\u01ce\u01cf"+
-		"\3\2\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d1\7+\2\2\u01d1\u01d2\7U\2\2\u01d2"+
-		"\u01d3\7Y\2\2\u01d3\u01d5\7*\2\2\u01d4\u01d6\5f\64\2\u01d5\u01d4\3\2\2"+
-		"\2\u01d5\u01d6\3\2\2\2\u01d6\u01d7\3\2\2\2\u01d7\u01d8\7+\2\2\u01d8\u01d9"+
-		"\7U\2\2\u01d9\u01db\7*\2\2\u01da\u01dc\5h\65\2\u01db\u01da\3\2\2\2\u01db"+
-		"\u01dc\3\2\2\2\u01dc\u01dd\3\2\2\2\u01dd\u01e0\7+\2\2\u01de\u01e1\5`\61"+
-		"\2\u01df\u01e1\5V,\2\u01e0\u01de\3\2\2\2\u01e0\u01df\3\2\2\2\u01e1_\3"+
-		"\2\2\2\u01e2\u01e3\7\21\2\2\u01e3\u01e4\5@!\2\u01e4a\3\2\2\2\u01e5\u01ed"+
-		"\5d\63\2\u01e6\u01e8\7\20\2\2\u01e7\u01e9\7q\2\2\u01e8\u01e7\3\2\2\2\u01e8"+
-		"\u01e9\3\2\2\2\u01e9\u01ea\3\2\2\2\u01ea\u01ec\5d\63\2\u01eb\u01e6\3\2"+
-		"\2\2\u01ec\u01ef\3\2\2\2\u01ed\u01eb\3\2\2\2\u01ed\u01ee\3\2\2\2\u01ee"+
-		"c\3\2\2\2\u01ef\u01ed\3\2\2\2\u01f0\u01f1\5\66\34\2\u01f1\u01f2\7\4\2"+
-		"\2\u01f2\u01f3\5\32\16\2\u01f3\u01f6\7Z\2\2\u01f4\u01f7\5<\37\2\u01f5"+
-		"\u01f7\5> \2\u01f6\u01f4\3\2\2\2\u01f6\u01f5\3\2\2\2\u01f7e\3\2\2\2\u01f8"+
-		"\u01fd\5:\36\2\u01f9\u01fa\7\20\2\2\u01fa\u01fc\5:\36\2\u01fb\u01f9\3"+
-		"\2\2\2\u01fc\u01ff\3\2\2\2\u01fd\u01fb\3\2\2\2\u01fd\u01fe\3\2\2\2\u01fe"+
-		"g\3\2\2\2\u01ff\u01fd\3\2\2\2\u0200\u0208\5j\66\2\u0201\u0203\7\20\2\2"+
-		"\u0202\u0204\7q\2\2\u0203\u0202\3\2\2\2\u0203\u0204\3\2\2\2\u0204\u0205"+
-		"\3\2\2\2\u0205\u0207\5j\66\2\u0206\u0201\3\2\2\2\u0207\u020a\3\2\2\2\u0208"+
-		"\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209i\3\2\2\2\u020a\u0208\3\2\2\2"+
-		"\u020b\u020c\5\32\16\2\u020c\u020f\7Z\2\2\u020d\u0210\5<\37\2\u020e\u0210"+
-		"\5> \2\u020f\u020d\3\2\2\2\u020f\u020e\3\2\2\2\u0210k\3\2\2\2\u0211\u0212"+
-		"\7[\2\2\u0212\u0214\5&\24\2\u0213\u0215\7q\2\2\u0214\u0213\3\2\2\2\u0214"+
-		"\u0215\3\2\2\2\u0215\u0218\3\2\2\2\u0216\u0219\5\b\5\2\u0217\u0219\5V"+
-		",\2\u0218\u0216\3\2\2\2\u0218\u0217\3\2\2\2\u0219\u021b\3\2\2\2\u021a"+
-		"\u021c\7q\2\2\u021b\u021a\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021e\3\2"+
-		"\2\2\u021d\u021f\5n8\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2\2\2\u021f\u0220"+
-		"\3\2\2\2\u0220\u0221\7q\2\2\u0221m\3\2\2\2\u0222\u0224\7\\\2\2\u0223\u0225"+
-		"\7q\2\2\u0224\u0223\3\2\2\2\u0224\u0225\3\2\2\2\u0225\u0228\3\2\2\2\u0226"+
-		"\u0229\5\b\5\2\u0227\u0229\5V,\2\u0228\u0226\3\2\2\2\u0228\u0227\3\2\2"+
-		"\2\u0229o\3\2\2\2\u022a\u022c\5r:\2\u022b\u022d\7q\2\2\u022c\u022b\3\2"+
-		"\2\2\u022c\u022d\3\2\2\2\u022d\u0230\3\2\2\2\u022e\u0231\5\b\5\2\u022f"+
-		"\u0231\5V,\2\u0230\u022e\3\2\2\2\u0230\u022f\3\2\2\2\u0231\u0233\3\2\2"+
-		"\2\u0232\u0234\7q\2\2\u0233\u0232\3\2\2\2\u0233\u0234\3\2\2\2\u0234\u0236"+
-		"\3\2\2\2\u0235\u0237\5n8\2\u0236\u0235\3\2\2\2\u0236\u0237\3\2\2\2\u0237"+
-		"\u0238\3\2\2\2\u0238\u0239\7q\2\2\u0239q\3\2\2\2\u023a\u023b\t\20\2\2"+
-		"\u023bs\3\2\2\2\u023c\u023e\7i\2\2\u023d\u023f\5\32\16\2\u023e\u023d\3"+
-		"\2\2\2\u023e\u023f\3\2\2\2\u023f\u0242\3\2\2\2\u0240\u0243\5:\36\2\u0241"+
-		"\u0243\5\66\34\2\u0242\u0240\3\2\2\2\u0242\u0241\3\2\2\2\u0243\u0244\3"+
-		"\2\2\2\u0244\u0245\7j\2\2\u0245\u0247\5&\24\2\u0246\u0248\7q\2\2\u0247"+
-		"\u0246\3\2\2\2\u0247\u0248\3\2\2\2\u0248\u0249\3\2\2\2\u0249\u024a\5V"+
-		",\2\u024au\3\2\2\2\u024b\u024c\7k\2\2\u024c\u024e\5&\24\2\u024d\u024f"+
-		"\7q\2\2\u024e\u024d\3\2\2\2\u024e\u024f\3\2\2\2\u024f\u0252\3\2\2\2\u0250"+
-		"\u0253\5\b\5\2\u0251\u0253\5V,\2\u0252\u0250\3\2\2\2\u0252\u0251\3\2\2"+
-		"\2\u0253w\3\2\2\2\u0254\u0257\7l\2\2\u0255\u0258\5\b\5\2\u0256\u0258\5"+
-		"V,\2\u0257\u0255\3\2\2\2\u0257\u0256\3\2\2\2\u0258\u025a\3\2\2\2\u0259"+
-		"\u025b\7q\2\2\u025a\u0259\3\2\2\2\u025a\u025b\3\2\2\2\u025b\u025c\3\2"+
-		"\2\2\u025c\u025d\7m\2\2\u025d\u025e\5&\24\2\u025ey\3\2\2\2F|~\u0085\u008a"+
-		"\u00a5\u00ae\u00b2\u00b9\u00bc\u00c1\u00c5\u00cb\u00e9\u00fd\u0125\u0127"+
-		"\u0129\u012e\u0134\u0138\u013e\u0142\u0149\u014e\u0153\u0160\u016a\u0172"+
-		"\u0177\u017c\u0180\u0190\u0199\u019d\u01a9\u01ab\u01b3\u01b8\u01c2\u01c7"+
-		"\u01ce\u01d5\u01db\u01e0\u01e8\u01ed\u01f6\u01fd\u0203\u0208\u020f\u0214"+
-		"\u0218\u021b\u021e\u0224\u0228\u022c\u0230\u0233\u0236\u023e\u0242\u0247"+
-		"\u024e\u0252\u0257\u025a";
+		"\4>\t>\3\2\3\2\7\2\177\n\2\f\2\16\2\u0082\13\2\3\2\3\2\3\3\3\3\5\3\u0088"+
+		"\n\3\3\4\3\4\3\4\5\4\u008d\n\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\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\5\5\u00a8"+
+		"\n\5\3\6\3\6\3\6\3\7\3\7\3\7\3\7\5\7\u00b1\n\7\3\b\3\b\5\b\u00b5\n\b\3"+
+		"\b\3\b\3\b\7\b\u00ba\n\b\f\b\16\b\u00bd\13\b\5\b\u00bf\n\b\3\t\3\t\3\t"+
+		"\5\t\u00c4\n\t\3\n\3\n\5\n\u00c8\n\n\3\n\3\n\3\13\3\13\5\13\u00ce\n\13"+
+		"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\17"+
+		"\3\17\3\20\3\20\3\20\3\20\3\21\3\21\3\21\7\21\u00e7\n\21\f\21\16\21\u00ea"+
+		"\13\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\5\23\u00f4\n\23\3\24\3"+
+		"\24\3\24\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3"+
+		"\25\3\25\3\25\5\25\u0108\n\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25"+
+		"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25"+
+		"\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25\3\25"+
+		"\3\25\3\25\5\25\u0130\n\25\7\25\u0132\n\25\f\25\16\25\u0135\13\25\3\26"+
+		"\3\26\5\26\u0139\n\26\3\26\3\26\3\27\3\27\5\27\u013f\n\27\3\27\3\27\5"+
+		"\27\u0143\n\27\3\27\3\27\3\30\3\30\5\30\u0149\n\30\3\30\3\30\5\30\u014d"+
+		"\n\30\3\30\3\30\3\31\3\31\3\31\5\31\u0154\n\31\3\31\7\31\u0157\n\31\f"+
+		"\31\16\31\u015a\13\31\3\32\3\32\5\32\u015e\n\32\3\33\3\33\3\34\3\34\3"+
+		"\35\3\35\3\36\3\36\3\36\6\36\u0169\n\36\r\36\16\36\u016a\3\37\3\37\3 "+
+		"\3 \3!\3!\3\"\3\"\5\"\u0175\n\"\3#\3#\3$\3$\3%\3%\5%\u017d\n%\3%\3%\3"+
+		"%\5%\u0182\n%\3%\7%\u0185\n%\f%\16%\u0188\13%\3%\5%\u018b\n%\3%\3%\3&"+
+		"\3&\3\'\3\'\3(\3(\3)\3)\3)\3)\3)\3)\5)\u019b\n)\3*\3*\3*\3+\3+\3+\3+\5"+
+		"+\u01a4\n+\3+\3+\5+\u01a8\n+\3+\3+\3+\3,\3,\3,\3-\3-\3-\3-\7-\u01b4\n"+
+		"-\f-\16-\u01b7\13-\3-\3-\3.\3.\3.\5.\u01be\n.\3.\7.\u01c1\n.\f.\16.\u01c4"+
+		"\13.\3/\3/\3/\3/\3\60\3\60\3\60\5\60\u01cd\n\60\3\60\7\60\u01d0\n\60\f"+
+		"\60\16\60\u01d3\13\60\3\61\3\61\3\61\3\61\5\61\u01d9\n\61\3\61\3\61\3"+
+		"\61\3\61\3\61\5\61\u01e0\n\61\3\61\3\61\3\61\3\61\5\61\u01e6\n\61\3\61"+
+		"\3\61\3\61\5\61\u01eb\n\61\3\62\3\62\3\62\3\63\3\63\3\63\5\63\u01f3\n"+
+		"\63\3\63\7\63\u01f6\n\63\f\63\16\63\u01f9\13\63\3\64\3\64\3\64\3\64\3"+
+		"\64\3\64\5\64\u0201\n\64\3\65\3\65\3\65\7\65\u0206\n\65\f\65\16\65\u0209"+
+		"\13\65\3\66\3\66\3\66\5\66\u020e\n\66\3\66\7\66\u0211\n\66\f\66\16\66"+
+		"\u0214\13\66\3\67\3\67\3\67\3\67\5\67\u021a\n\67\38\38\38\58\u021f\n8"+
+		"\38\38\58\u0223\n8\38\58\u0226\n8\38\58\u0229\n8\38\38\39\39\59\u022f"+
+		"\n9\39\39\59\u0233\n9\3:\3:\5:\u0237\n:\3:\3:\5:\u023b\n:\3:\5:\u023e"+
+		"\n:\3:\5:\u0241\n:\3:\3:\3;\3;\3<\3<\5<\u0249\n<\3<\3<\5<\u024d\n<\3<"+
+		"\3<\3<\5<\u0252\n<\3<\3<\3=\3=\3=\5=\u0259\n=\3=\3=\5=\u025d\n=\3>\3>"+
+		"\3>\5>\u0262\n>\3>\5>\u0265\n>\3>\3>\3>\3>\2\3(?\2\4\6\b\n\f\16\20\22"+
+		"\24\26\30\32\34\36 \"$&(*,.\60\62\64\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnp"+
+		"rtvxz\2\21\3\2\6\17\3\2\24\34\3\2\37\'\3\2()\4\2\3\3,-\3\2/\62\3\2,-\3"+
+		"\2\63\66\3\2\678\3\2FH\3\2FK\3\2LO\3\2su\3\2QR\3\2]h\2\u029e\2\u0080\3"+
+		"\2\2\2\4\u0087\3\2\2\2\6\u0089\3\2\2\2\b\u00a7\3\2\2\2\n\u00a9\3\2\2\2"+
+		"\f\u00ac\3\2\2\2\16\u00b2\3\2\2\2\20\u00c3\3\2\2\2\22\u00c5\3\2\2\2\24"+
+		"\u00cb\3\2\2\2\26\u00d3\3\2\2\2\30\u00d6\3\2\2\2\32\u00d9\3\2\2\2\34\u00db"+
+		"\3\2\2\2\36\u00df\3\2\2\2 \u00e3\3\2\2\2\"\u00eb\3\2\2\2$\u00f3\3\2\2"+
+		"\2&\u00f5\3\2\2\2(\u0107\3\2\2\2*\u0138\3\2\2\2,\u013e\3\2\2\2.\u0148"+
+		"\3\2\2\2\60\u0150\3\2\2\2\62\u015b\3\2\2\2\64\u015f\3\2\2\2\66\u0161\3"+
+		"\2\2\28\u0163\3\2\2\2:\u0165\3\2\2\2<\u016c\3\2\2\2>\u016e\3\2\2\2@\u0170"+
+		"\3\2\2\2B\u0172\3\2\2\2D\u0176\3\2\2\2F\u0178\3\2\2\2H\u017a\3\2\2\2J"+
+		"\u018e\3\2\2\2L\u0190\3\2\2\2N\u0192\3\2\2\2P\u019a\3\2\2\2R\u019c\3\2"+
+		"\2\2T\u019f\3\2\2\2V\u01ac\3\2\2\2X\u01af\3\2\2\2Z\u01ba\3\2\2\2\\\u01c5"+
+		"\3\2\2\2^\u01c9\3\2\2\2`\u01d4\3\2\2\2b\u01ec\3\2\2\2d\u01ef\3\2\2\2f"+
+		"\u01fa\3\2\2\2h\u0202\3\2\2\2j\u020a\3\2\2\2l\u0215\3\2\2\2n\u021b\3\2"+
+		"\2\2p\u022c\3\2\2\2r\u0234\3\2\2\2t\u0244\3\2\2\2v\u0246\3\2\2\2x\u0255"+
+		"\3\2\2\2z\u025e\3\2\2\2|\177\5\4\3\2}\177\7q\2\2~|\3\2\2\2~}\3\2\2\2\177"+
+		"\u0082\3\2\2\2\u0080~\3\2\2\2\u0080\u0081\3\2\2\2\u0081\u0083\3\2\2\2"+
+		"\u0082\u0080\3\2\2\2\u0083\u0084\7\2\2\3\u0084\3\3\2\2\2\u0085\u0088\5"+
+		"\16\b\2\u0086\u0088\5\6\4\2\u0087\u0085\3\2\2\2\u0087\u0086\3\2\2\2\u0088"+
+		"\5\3\2\2\2\u0089\u008a\7\3\2\2\u008a\u008c\58\35\2\u008b\u008d\5B\"\2"+
+		"\u008c\u008b\3\2\2\2\u008c\u008d\3\2\2\2\u008d\u008e\3\2\2\2\u008e\u008f"+
+		"\5X-\2\u008f\u0090\7q\2\2\u0090\7\3\2\2\2\u0091\u00a8\5\16\b\2\u0092\u00a8"+
+		"\5\24\13\2\u0093\u00a8\5\22\n\2\u0094\u00a8\5\26\f\2\u0095\u00a8\5\30"+
+		"\r\2\u0096\u00a8\5\36\20\2\u0097\u00a8\5\"\22\2\u0098\u00a8\5\f\7\2\u0099"+
+		"\u00a8\5&\24\2\u009a\u00a8\5.\30\2\u009b\u00a8\5n8\2\u009c\u00a8\5r:\2"+
+		"\u009d\u00a8\5T+\2\u009e\u00a8\5`\61\2\u009f\u00a8\5R*\2\u00a0\u00a8\5"+
+		"\62\32\2\u00a1\u00a8\5v<\2\u00a2\u00a8\5x=\2\u00a3\u00a8\5z>\2\u00a4\u00a8"+
+		"\5\64\33\2\u00a5\u00a8\5\66\34\2\u00a6\u00a8\5\n\6\2\u00a7\u0091\3\2\2"+
+		"\2\u00a7\u0092\3\2\2\2\u00a7\u0093\3\2\2\2\u00a7\u0094\3\2\2\2\u00a7\u0095"+
+		"\3\2\2\2\u00a7\u0096\3\2\2\2\u00a7\u0097\3\2\2\2\u00a7\u0098\3\2\2\2\u00a7"+
+		"\u0099\3\2\2\2\u00a7\u009a\3\2\2\2\u00a7\u009b\3\2\2\2\u00a7\u009c\3\2"+
+		"\2\2\u00a7\u009d\3\2\2\2\u00a7\u009e\3\2\2\2\u00a7\u009f\3\2\2\2\u00a7"+
+		"\u00a0\3\2\2\2\u00a7\u00a1\3\2\2\2\u00a7\u00a2\3\2\2\2\u00a7\u00a3\3\2"+
+		"\2\2\u00a7\u00a4\3\2\2\2\u00a7\u00a5\3\2\2\2\u00a7\u00a6\3\2\2\2\u00a8"+
+		"\t\3\2\2\2\u00a9\u00aa\58\35\2\u00aa\u00ab\7\4\2\2\u00ab\13\3\2\2\2\u00ac"+
+		"\u00b0\7\5\2\2\u00ad\u00b1\5B\"\2\u00ae\u00b1\58\35\2\u00af\u00b1\5:\36"+
+		"\2\u00b0\u00ad\3\2\2\2\u00b0\u00ae\3\2\2\2\u00b0\u00af\3\2\2\2\u00b1\r"+
+		"\3\2\2\2\u00b2\u00be\t\2\2\2\u00b3\u00b5\5\20\t\2\u00b4\u00b3\3\2\2\2"+
+		"\u00b4\u00b5\3\2\2\2\u00b5\u00bf\3\2\2\2\u00b6\u00bb\5\20\t\2\u00b7\u00b8"+
+		"\7\20\2\2\u00b8\u00ba\5\20\t\2\u00b9\u00b7\3\2\2\2\u00ba\u00bd\3\2\2\2"+
+		"\u00bb\u00b9\3\2\2\2\u00bb\u00bc\3\2\2\2\u00bc\u00bf\3\2\2\2\u00bd\u00bb"+
+		"\3\2\2\2\u00be\u00b4\3\2\2\2\u00be\u00b6\3\2\2\2\u00bf\17\3\2\2\2\u00c0"+
+		"\u00c4\5J&\2\u00c1\u00c4\58\35\2\u00c2\u00c4\5B\"\2\u00c3\u00c0\3\2\2"+
+		"\2\u00c3\u00c1\3\2\2\2\u00c3\u00c2\3\2\2\2\u00c4\21\3\2\2\2\u00c5\u00c7"+
+		"\5\32\16\2\u00c6\u00c8\5\34\17\2\u00c7\u00c6\3\2\2\2\u00c7\u00c8\3\2\2"+
+		"\2\u00c8\u00c9\3\2\2\2\u00c9\u00ca\58\35\2\u00ca\23\3\2\2\2\u00cb\u00cd"+
+		"\5\32\16\2\u00cc\u00ce\5\34\17\2\u00cd\u00cc\3\2\2\2\u00cd\u00ce\3\2\2"+
+		"\2\u00ce\u00cf\3\2\2\2\u00cf\u00d0\58\35\2\u00d0\u00d1\7\21\2\2\u00d1"+
+		"\u00d2\5(\25\2\u00d2\25\3\2\2\2\u00d3\u00d4\7\22\2\2\u00d4\u00d5\5\24"+
+		"\13\2\u00d5\27\3\2\2\2\u00d6\u00d7\7\23\2\2\u00d7\u00d8\5\24\13\2\u00d8"+
+		"\31\3\2\2\2\u00d9\u00da\t\3\2\2\u00da\33\3\2\2\2\u00db\u00dc\7\35\2\2"+
+		"\u00dc\u00dd\5(\25\2\u00dd\u00de\7\36\2\2\u00de\35\3\2\2\2\u00df\u00e0"+
+		"\5 \21\2\u00e0\u00e1\7\21\2\2\u00e1\u00e2\5(\25\2\u00e2\37\3\2\2\2\u00e3"+
+		"\u00e8\5$\23\2\u00e4\u00e5\7\20\2\2\u00e5\u00e7\5$\23\2\u00e6\u00e4\3"+
+		"\2\2\2\u00e7\u00ea\3\2\2\2\u00e8\u00e6\3\2\2\2\u00e8\u00e9\3\2\2\2\u00e9"+
+		"!\3\2\2\2\u00ea\u00e8\3\2\2\2\u00eb\u00ec\5$\23\2\u00ec\u00ed\t\4\2\2"+
+		"\u00ed\u00ee\5(\25\2\u00ee#\3\2\2\2\u00ef\u00f4\5<\37\2\u00f0\u00f4\5"+
+		"8\35\2\u00f1\u00f4\5:\36\2\u00f2\u00f4\5*\26\2\u00f3\u00ef\3\2\2\2\u00f3"+
+		"\u00f0\3\2\2\2\u00f3\u00f1\3\2\2\2\u00f3\u00f2\3\2\2\2\u00f4%\3\2\2\2"+
+		"\u00f5\u00f6\5$\23\2\u00f6\u00f7\t\5\2\2\u00f7\'\3\2\2\2\u00f8\u00f9\b"+
+		"\25\1\2\u00f9\u00fa\7*\2\2\u00fa\u00fb\5(\25\2\u00fb\u00fc\7+\2\2\u00fc"+
+		"\u0108\3\2\2\2\u00fd\u0108\5,\27\2\u00fe\u00ff\t\6\2\2\u00ff\u0108\5("+
+		"\25\25\u0100\u0101\7A\2\2\u0101\u0108\5(\25\b\u0102\u0108\5P)\2\u0103"+
+		"\u0108\5<\37\2\u0104\u0108\58\35\2\u0105\u0108\5:\36\2\u0106\u0108\5*"+
+		"\26\2\u0107\u00f8\3\2\2\2\u0107\u00fd\3\2\2\2\u0107\u00fe\3\2\2\2\u0107"+
+		"\u0100\3\2\2\2\u0107\u0102\3\2\2\2\u0107\u0103\3\2\2\2\u0107\u0104\3\2"+
+		"\2\2\u0107\u0105\3\2\2\2\u0107\u0106\3\2\2\2\u0108\u0133\3\2\2\2\u0109"+
+		"\u010a\f\24\2\2\u010a\u010b\7.\2\2\u010b\u0132\5(\25\25\u010c\u010d\f"+
+		"\23\2\2\u010d\u010e\t\7\2\2\u010e\u0132\5(\25\24\u010f\u0110\f\22\2\2"+
+		"\u0110\u0111\t\b\2\2\u0111\u0132\5(\25\23\u0112\u0113\f\21\2\2\u0113\u0114"+
+		"\t\t\2\2\u0114\u0132\5(\25\22\u0115\u0116\f\20\2\2\u0116\u0117\t\n\2\2"+
+		"\u0117\u0132\5(\25\21\u0118\u0119\f\17\2\2\u0119\u011a\79\2\2\u011a\u0132"+
+		"\5(\25\20\u011b\u011c\f\16\2\2\u011c\u011d\7:\2\2\u011d\u0132\5(\25\17"+
+		"\u011e\u011f\f\r\2\2\u011f\u0120\7;\2\2\u0120\u0132\5(\25\16\u0121\u0122"+
+		"\f\13\2\2\u0122\u0123\7>\2\2\u0123\u0132\5(\25\f\u0124\u0125\f\n\2\2\u0125"+
+		"\u0126\7?\2\2\u0126\u0132\5(\25\13\u0127\u0128\f\t\2\2\u0128\u0129\7@"+
+		"\2\2\u0129\u0132\5(\25\n\u012a\u012b\f\f\2\2\u012b\u012c\7<\2\2\u012c"+
+		"\u012f\5(\25\2\u012d\u012e\7=\2\2\u012e\u0130\5(\25\2\u012f\u012d\3\2"+
+		"\2\2\u012f\u0130\3\2\2\2\u0130\u0132\3\2\2\2\u0131\u0109\3\2\2\2\u0131"+
+		"\u010c\3\2\2\2\u0131\u010f\3\2\2\2\u0131\u0112\3\2\2\2\u0131\u0115\3\2"+
+		"\2\2\u0131\u0118\3\2\2\2\u0131\u011b\3\2\2\2\u0131\u011e\3\2\2\2\u0131"+
+		"\u0121\3\2\2\2\u0131\u0124\3\2\2\2\u0131\u0127\3\2\2\2\u0131\u012a\3\2"+
+		"\2\2\u0132\u0135\3\2\2\2\u0133\u0131\3\2\2\2\u0133\u0134\3\2\2\2\u0134"+
+		")\3\2\2\2\u0135\u0133\3\2\2\2\u0136\u0139\58\35\2\u0137\u0139\5:\36\2"+
+		"\u0138\u0136\3\2\2\2\u0138\u0137\3\2\2\2\u0139\u013a\3\2\2\2\u013a\u013b"+
+		"\5\34\17\2\u013b+\3\2\2\2\u013c\u013f\58\35\2\u013d\u013f\5:\36\2\u013e"+
+		"\u013c\3\2\2\2\u013e\u013d\3\2\2\2\u013f\u0140\3\2\2\2\u0140\u0142\7*"+
+		"\2\2\u0141\u0143\5\60\31\2\u0142\u0141\3\2\2\2\u0142\u0143\3\2\2\2\u0143"+
+		"\u0144\3\2\2\2\u0144\u0145\7+\2\2\u0145-\3\2\2\2\u0146\u0149\58\35\2\u0147"+
+		"\u0149\5:\36\2\u0148\u0146\3\2\2\2\u0148\u0147\3\2\2\2\u0149\u014a\3\2"+
+		"\2\2\u014a\u014c\7*\2\2\u014b\u014d\5\60\31\2\u014c\u014b\3\2\2\2\u014c"+
+		"\u014d\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f\7+\2\2\u014f/\3\2\2\2\u0150"+
+		"\u0158\5(\25\2\u0151\u0153\7\20\2\2\u0152\u0154\7q\2\2\u0153\u0152\3\2"+
+		"\2\2\u0153\u0154\3\2\2\2\u0154\u0155\3\2\2\2\u0155\u0157\5(\25\2\u0156"+
+		"\u0151\3\2\2\2\u0157\u015a\3\2\2\2\u0158\u0156\3\2\2\2\u0158\u0159\3\2"+
+		"\2\2\u0159\61\3\2\2\2\u015a\u0158\3\2\2\2\u015b\u015d\7B\2\2\u015c\u015e"+
+		"\5\60\31\2\u015d\u015c\3\2\2\2\u015d\u015e\3\2\2\2\u015e\63\3\2\2\2\u015f"+
+		"\u0160\7C\2\2\u0160\65\3\2\2\2\u0161\u0162\7D\2\2\u0162\67\3\2\2\2\u0163"+
+		"\u0164\7r\2\2\u01649\3\2\2\2\u0165\u0168\7r\2\2\u0166\u0167\7E\2\2\u0167"+
+		"\u0169\7r\2\2\u0168\u0166\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u0168\3\2"+
+		"\2\2\u016a\u016b\3\2\2\2\u016b;\3\2\2\2\u016c\u016d\t\13\2\2\u016d=\3"+
+		"\2\2\2\u016e\u016f\t\f\2\2\u016f?\3\2\2\2\u0170\u0171\t\r\2\2\u0171A\3"+
+		"\2\2\2\u0172\u0174\t\16\2\2\u0173\u0175\5D#\2\u0174\u0173\3\2\2\2\u0174"+
+		"\u0175\3\2\2\2\u0175C\3\2\2\2\u0176\u0177\7P\2\2\u0177E\3\2\2\2\u0178"+
+		"\u0179\t\17\2\2\u0179G\3\2\2\2\u017a\u017c\7\35\2\2\u017b\u017d\7q\2\2"+
+		"\u017c\u017b\3\2\2\2\u017c\u017d\3\2\2\2\u017d\u017e\3\2\2\2\u017e\u0186"+
+		"\5(\25\2\u017f\u0181\7\20\2\2\u0180\u0182\7q\2\2\u0181\u0180\3\2\2\2\u0181"+
+		"\u0182\3\2\2\2\u0182\u0183\3\2\2\2\u0183\u0185\5(\25\2\u0184\u017f\3\2"+
+		"\2\2\u0185\u0188\3\2\2\2\u0186\u0184\3\2\2\2\u0186\u0187\3\2\2\2\u0187"+
+		"\u018a\3\2\2\2\u0188\u0186\3\2\2\2\u0189\u018b\7q\2\2\u018a\u0189\3\2"+
+		"\2\2\u018a\u018b\3\2\2\2\u018b\u018c\3\2\2\2\u018c\u018d\7\36\2\2\u018d"+
+		"I\3\2\2\2\u018e\u018f\7w\2\2\u018fK\3\2\2\2\u0190\u0191\7y\2\2\u0191M"+
+		"\3\2\2\2\u0192\u0193\7v\2\2\u0193O\3\2\2\2\u0194\u019b\5B\"\2\u0195\u019b"+
+		"\5F$\2\u0196\u019b\5H%\2\u0197\u019b\5J&\2\u0198\u019b\5L\'\2\u0199\u019b"+
+		"\5N(\2\u019a\u0194\3\2\2\2\u019a\u0195\3\2\2\2\u019a\u0196\3\2\2\2\u019a"+
+		"\u0197\3\2\2\2\u019a\u0198\3\2\2\2\u019a\u0199\3\2\2\2\u019bQ\3\2\2\2"+
+		"\u019c\u019d\7S\2\2\u019d\u019e\7x\2\2\u019eS\3\2\2\2\u019f\u01a0\7T\2"+
+		"\2\u01a0\u01a1\58\35\2\u01a1\u01a3\7*\2\2\u01a2\u01a4\5Z.\2\u01a3\u01a2"+
+		"\3\2\2\2\u01a3\u01a4\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\u01a7\7+\2\2\u01a6"+
+		"\u01a8\5V,\2\u01a7\u01a6\3\2\2\2\u01a7\u01a8\3\2\2\2\u01a8\u01a9\3\2\2"+
+		"\2\u01a9\u01aa\5X-\2\u01aa\u01ab\7q\2\2\u01abU\3\2\2\2\u01ac\u01ad\7U"+
+		"\2\2\u01ad\u01ae\5^\60\2\u01aeW\3\2\2\2\u01af\u01b0\7V\2\2\u01b0\u01b5"+
+		"\7q\2\2\u01b1\u01b4\5\b\5\2\u01b2\u01b4\7q\2\2\u01b3\u01b1\3\2\2\2\u01b3"+
+		"\u01b2\3\2\2\2\u01b4\u01b7\3\2\2\2\u01b5\u01b3\3\2\2\2\u01b5\u01b6\3\2"+
+		"\2\2\u01b6\u01b8\3\2\2\2\u01b7\u01b5\3\2\2\2\u01b8\u01b9\7W\2\2\u01b9"+
+		"Y\3\2\2\2\u01ba\u01c2\5\\/\2\u01bb\u01bd\7\20\2\2\u01bc\u01be\7q\2\2\u01bd"+
+		"\u01bc\3\2\2\2\u01bd\u01be\3\2\2\2\u01be\u01bf\3\2\2\2\u01bf\u01c1\5\\"+
+		"/\2\u01c0\u01bb\3\2\2\2\u01c1\u01c4\3\2\2\2\u01c2\u01c0\3\2\2\2\u01c2"+
+		"\u01c3\3\2\2\2\u01c3[\3\2\2\2\u01c4\u01c2\3\2\2\2\u01c5\u01c6\58\35\2"+
+		"\u01c6\u01c7\7\4\2\2\u01c7\u01c8\5\32\16\2\u01c8]\3\2\2\2\u01c9\u01d1"+
+		"\5\32\16\2\u01ca\u01cc\7\20\2\2\u01cb\u01cd\7q\2\2\u01cc\u01cb\3\2\2\2"+
+		"\u01cc\u01cd\3\2\2\2\u01cd\u01ce\3\2\2\2\u01ce\u01d0\5\32\16\2\u01cf\u01ca"+
+		"\3\2\2\2\u01d0\u01d3\3\2\2\2\u01d1\u01cf\3\2\2\2\u01d1\u01d2\3\2\2\2\u01d2"+
+		"_\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d4\u01d5\7X\2\2\u01d5\u01d6\58\35\2\u01d6"+
+		"\u01d8\7*\2\2\u01d7\u01d9\5d\63\2\u01d8\u01d7\3\2\2\2\u01d8\u01d9\3\2"+
+		"\2\2\u01d9\u01da\3\2\2\2\u01da\u01db\7+\2\2\u01db\u01dc\7U\2\2\u01dc\u01dd"+
+		"\7Y\2\2\u01dd\u01df\7*\2\2\u01de\u01e0\5h\65\2\u01df\u01de\3\2\2\2\u01df"+
+		"\u01e0\3\2\2\2\u01e0\u01e1\3\2\2\2\u01e1\u01e2\7+\2\2\u01e2\u01e3\7U\2"+
+		"\2\u01e3\u01e5\7*\2\2\u01e4\u01e6\5j\66\2\u01e5\u01e4\3\2\2\2\u01e5\u01e6"+
+		"\3\2\2\2\u01e6\u01e7\3\2\2\2\u01e7\u01ea\7+\2\2\u01e8\u01eb\5b\62\2\u01e9"+
+		"\u01eb\5X-\2\u01ea\u01e8\3\2\2\2\u01ea\u01e9\3\2\2\2\u01eba\3\2\2\2\u01ec"+
+		"\u01ed\7\21\2\2\u01ed\u01ee\5B\"\2\u01eec\3\2\2\2\u01ef\u01f7\5f\64\2"+
+		"\u01f0\u01f2\7\20\2\2\u01f1\u01f3\7q\2\2\u01f2\u01f1\3\2\2\2\u01f2\u01f3"+
+		"\3\2\2\2\u01f3\u01f4\3\2\2\2\u01f4\u01f6\5f\64\2\u01f5\u01f0\3\2\2\2\u01f6"+
+		"\u01f9\3\2\2\2\u01f7\u01f5\3\2\2\2\u01f7\u01f8\3\2\2\2\u01f8e\3\2\2\2"+
+		"\u01f9\u01f7\3\2\2\2\u01fa\u01fb\58\35\2\u01fb\u01fc\7\4\2\2\u01fc\u01fd"+
+		"\5\32\16\2\u01fd\u0200\7Z\2\2\u01fe\u0201\5> \2\u01ff\u0201\5@!\2\u0200"+
+		"\u01fe\3\2\2\2\u0200\u01ff\3\2\2\2\u0201g\3\2\2\2\u0202\u0207\5<\37\2"+
+		"\u0203\u0204\7\20\2\2\u0204\u0206\5<\37\2\u0205\u0203\3\2\2\2\u0206\u0209"+
+		"\3\2\2\2\u0207\u0205\3\2\2\2\u0207\u0208\3\2\2\2\u0208i\3\2\2\2\u0209"+
+		"\u0207\3\2\2\2\u020a\u0212\5l\67\2\u020b\u020d\7\20\2\2\u020c\u020e\7"+
+		"q\2\2\u020d\u020c\3\2\2\2\u020d\u020e\3\2\2\2\u020e\u020f\3\2\2\2\u020f"+
+		"\u0211\5l\67\2\u0210\u020b\3\2\2\2\u0211\u0214\3\2\2\2\u0212\u0210\3\2"+
+		"\2\2\u0212\u0213\3\2\2\2\u0213k\3\2\2\2\u0214\u0212\3\2\2\2\u0215\u0216"+
+		"\5\32\16\2\u0216\u0219\7Z\2\2\u0217\u021a\5> \2\u0218\u021a\5@!\2\u0219"+
+		"\u0217\3\2\2\2\u0219\u0218\3\2\2\2\u021am\3\2\2\2\u021b\u021c\7[\2\2\u021c"+
+		"\u021e\5(\25\2\u021d\u021f\7q\2\2\u021e\u021d\3\2\2\2\u021e\u021f\3\2"+
+		"\2\2\u021f\u0222\3\2\2\2\u0220\u0223\5\b\5\2\u0221\u0223\5X-\2\u0222\u0220"+
+		"\3\2\2\2\u0222\u0221\3\2\2\2\u0223\u0225\3\2\2\2\u0224\u0226\7q\2\2\u0225"+
+		"\u0224\3\2\2\2\u0225\u0226\3\2\2\2\u0226\u0228\3\2\2\2\u0227\u0229\5p"+
+		"9\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229\u022a\3\2\2\2\u022a"+
+		"\u022b\7q\2\2\u022bo\3\2\2\2\u022c\u022e\7\\\2\2\u022d\u022f\7q\2\2\u022e"+
+		"\u022d\3\2\2\2\u022e\u022f\3\2\2\2\u022f\u0232\3\2\2\2\u0230\u0233\5\b"+
+		"\5\2\u0231\u0233\5X-\2\u0232\u0230\3\2\2\2\u0232\u0231\3\2\2\2\u0233q"+
+		"\3\2\2\2\u0234\u0236\5t;\2\u0235\u0237\7q\2\2\u0236\u0235\3\2\2\2\u0236"+
+		"\u0237\3\2\2\2\u0237\u023a\3\2\2\2\u0238\u023b\5\b\5\2\u0239\u023b\5X"+
+		"-\2\u023a\u0238\3\2\2\2\u023a\u0239\3\2\2\2\u023b\u023d\3\2\2\2\u023c"+
+		"\u023e\7q\2\2\u023d\u023c\3\2\2\2\u023d\u023e\3\2\2\2\u023e\u0240\3\2"+
+		"\2\2\u023f\u0241\5p9\2\u0240\u023f\3\2\2\2\u0240\u0241\3\2\2\2\u0241\u0242"+
+		"\3\2\2\2\u0242\u0243\7q\2\2\u0243s\3\2\2\2\u0244\u0245\t\20\2\2\u0245"+
+		"u\3\2\2\2\u0246\u0248\7i\2\2\u0247\u0249\5\32\16\2\u0248\u0247\3\2\2\2"+
+		"\u0248\u0249\3\2\2\2\u0249\u024c\3\2\2\2\u024a\u024d\5<\37\2\u024b\u024d"+
+		"\58\35\2\u024c\u024a\3\2\2\2\u024c\u024b\3\2\2\2\u024d\u024e\3\2\2\2\u024e"+
+		"\u024f\7j\2\2\u024f\u0251\5(\25\2\u0250\u0252\7q\2\2\u0251\u0250\3\2\2"+
+		"\2\u0251\u0252\3\2\2\2\u0252\u0253\3\2\2\2\u0253\u0254\5X-\2\u0254w\3"+
+		"\2\2\2\u0255\u0256\7k\2\2\u0256\u0258\5(\25\2\u0257\u0259\7q\2\2\u0258"+
+		"\u0257\3\2\2\2\u0258\u0259\3\2\2\2\u0259\u025c\3\2\2\2\u025a\u025d\5\b"+
+		"\5\2\u025b\u025d\5X-\2\u025c\u025a\3\2\2\2\u025c\u025b\3\2\2\2\u025dy"+
+		"\3\2\2\2\u025e\u0261\7l\2\2\u025f\u0262\5\b\5\2\u0260\u0262\5X-\2\u0261"+
+		"\u025f\3\2\2\2\u0261\u0260\3\2\2\2\u0262\u0264\3\2\2\2\u0263\u0265\7q"+
+		"\2\2\u0264\u0263\3\2\2\2\u0264\u0265\3\2\2\2\u0265\u0266\3\2\2\2\u0266"+
+		"\u0267\7m\2\2\u0267\u0268\5(\25\2\u0268{\3\2\2\2G~\u0080\u0087\u008c\u00a7"+
+		"\u00b0\u00b4\u00bb\u00be\u00c3\u00c7\u00cd\u00e8\u00f3\u0107\u012f\u0131"+
+		"\u0133\u0138\u013e\u0142\u0148\u014c\u0153\u0158\u015d\u016a\u0174\u017c"+
+		"\u0181\u0186\u018a\u019a\u01a3\u01a7\u01b3\u01b5\u01bd\u01c2\u01cc\u01d1"+
+		"\u01d8\u01df\u01e5\u01ea\u01f2\u01f7\u0200\u0207\u020d\u0212\u0219\u021e"+
+		"\u0222\u0225\u0228\u022e\u0232\u0236\u023a\u023d\u0240\u0248\u024c\u0251"+
+		"\u0258\u025c\u0261\u0264";
 	public static final ATN _ATN =
 		new ATNDeserializer().deserialize(_serializedATN.toCharArray());
 	static {