From 1069b5f5d5a54d8d6062459fb4b50de46934a1a4 Mon Sep 17 00:00:00 2001 From: Irmen de Jong Date: Thu, 4 Apr 2019 21:02:24 +0200 Subject: [PATCH] w.i.p pointer-to --- compiler/src/prog8/ast/AST.kt | 34 +- compiler/src/prog8/ast/AstChecker.kt | 37 +- compiler/src/prog8/compiler/Compiler.kt | 51 +- .../src/prog8/compiler/target/c64/AsmGen.kt | 23 +- .../src/prog8/functions/BuiltinFunctions.kt | 21 +- .../src/prog8/optimizing/ConstantFolding.kt | 30 +- compiler/src/prog8/stackvm/Program.kt | 9 +- compiler/src/prog8/stackvm/StackVm.kt | 97 +- examples/test.p8 | 57 +- parser/antlr/prog8.g4 | 3 + parser/src/prog8/parser/prog8Lexer.java | 2 +- parser/src/prog8/parser/prog8Parser.java | 1630 +++++++++-------- 12 files changed, 1079 insertions(+), 915 deletions(-) diff --git a/compiler/src/prog8/ast/AST.kt b/compiler/src/prog8/ast/AST.kt index 332a299a4..af66734c1 100644 --- a/compiler/src/prog8/ast/AST.kt +++ b/compiler/src/prog8/ast/AST.kt @@ -42,13 +42,10 @@ enum class DataType { UWORD -> targetType == UWORD || targetType == FLOAT WORD -> targetType == WORD || targetType==UWORD || targetType == FLOAT FLOAT -> targetType == FLOAT - STR -> targetType == STR || targetType==STR_S || targetType == UWORD - STR_S -> targetType == STR || targetType==STR_S || targetType == UWORD - ARRAY_UB -> targetType == UWORD || targetType==ARRAY_UB - ARRAY_B -> targetType == UWORD || targetType==ARRAY_B - ARRAY_UW -> targetType == UWORD || targetType==ARRAY_UW - ARRAY_W -> targetType == UWORD || targetType==ARRAY_W - ARRAY_F -> targetType == UWORD || targetType==ARRAY_F + STR -> targetType == STR || targetType==STR_S + STR_S -> targetType == STR || targetType==STR_S + in ArrayDatatypes -> targetType === this + else -> false } @@ -291,6 +288,10 @@ interface IAstProcessor { memwrite.addressExpression = memwrite.addressExpression.process(this) return memwrite } + + fun process(pointerOf: PointerOf): IExpression { + return pointerOf + } } @@ -1009,6 +1010,22 @@ class TypecastExpression(var expression: IExpression, var type: DataType, overri } +data class PointerOf(val identifier: IdentifierReference, override val position: Position) : IExpression { + override lateinit var parent: Node + + override fun linkParents(parent: Node) { + this.parent = parent + identifier.parent=this + } + + override fun isIterable(namespace: INameScope, heap: HeapValues) = false + override fun constValue(namespace: INameScope, heap: HeapValues): LiteralValue? = null + override fun referencesIdentifier(name: String) = false + override fun resultingDatatype(namespace: INameScope, heap: HeapValues) = DataType.UWORD + override fun process(processor: IAstProcessor) = processor.process(this) +} + + class DirectMemoryRead(var addressExpression: IExpression, override val position: Position) : IExpression { override lateinit var parent: Node @@ -2196,6 +2213,9 @@ private fun prog8Parser.ExpressionContext.toAst() : IExpression { if(directmemory()!=null) return DirectMemoryRead(directmemory().expression().toAst(), toPosition()) + if(pointerof()!=null) + return PointerOf(pointerof().scoped_identifier().toAst(), toPosition()) + throw FatalAstException(text) } diff --git a/compiler/src/prog8/ast/AstChecker.kt b/compiler/src/prog8/ast/AstChecker.kt index 115179175..d520453e7 100644 --- a/compiler/src/prog8/ast/AstChecker.kt +++ b/compiler/src/prog8/ast/AstChecker.kt @@ -58,7 +58,7 @@ private class AstChecker(private val namespace: INameScope, private val heapStringSentinel: Int init { val stringSentinel = heap.allEntries().firstOrNull {it.value.str==""} - heapStringSentinel = stringSentinel?.key ?: heap.add(DataType.STR, "") + heapStringSentinel = stringSentinel?.key ?: heap.addString(DataType.STR, "") } fun result(): List { @@ -401,23 +401,10 @@ private class AstChecker(private val namespace: INameScope, checkResult.add(ExpressionError("cannot assign new value to a constant", assignment.position)) return assignment } - if(assignment.value.resultingDatatype(namespace, heap) in ArrayDatatypes) { - if(targetSymbol.datatype==DataType.UWORD) - return assignment // array can be assigned to UWORD (it's address should be taken as the value then) - } } } } - // it is only possible to assign an array to something that is an UWORD or UWORD array (in which case the address of the array value is used as the value) - if(assignment.value.resultingDatatype(namespace, heap) in ArrayDatatypes) { - // the UWORD case has been handled above already, check for UWORD array - val arrayVar = target.arrayindexed?.identifier?.targetStatement(namespace) - if(arrayVar is VarDecl && arrayVar.datatype==DataType.ARRAY_UW) - return assignment - checkResult.add(SyntaxError("it's not possible to assign an array to something other than an UWORD, use it as a variable decl initializer instead", assignment.position)) - } - if(assignment.aug_op!=null) { // check augmented assignment (and convert it into a normal assignment!) // A /= 3 -> check as if it was A = A / 3 @@ -468,6 +455,16 @@ private class AstChecker(private val namespace: INameScope, return assignment } + override fun process(pointerOf: PointerOf): IExpression { + val variable=pointerOf.identifier.targetStatement(namespace) as? VarDecl + if(variable==null) + checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", pointerOf.position)) + else { + if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes) + checkResult.add(ExpressionError("pointer-of operand must be the name of a string or array heap variable", pointerOf.position)) + } + return pointerOf + } /** * Check the variable declarations (values within range etc) @@ -984,8 +981,6 @@ private class AstChecker(private val namespace: INameScope, return err("value '$number' out of range for byte") } DataType.UWORD -> { - if(value.isString || value.isArray) // string or array are assignable to uword; their memory address is used. - return true val number = value.asIntegerValue ?: return if (value.floatvalue!=null) err("unsigned word value expected instead of float; possible loss of precision") else @@ -1091,16 +1086,16 @@ private class AstChecker(private val namespace: INameScope, val correct: Boolean when(type) { DataType.ARRAY_UB -> { - correct=array.array!=null && array.array.all { it in 0..255 } + correct=array.array!=null && array.array.all { it.integer!=null && it.integer in 0..255 } } DataType.ARRAY_B -> { - correct=array.array!=null && array.array.all { it in -128..127 } + correct=array.array!=null && array.array.all { it.integer!=null && it.integer in -128..127 } } DataType.ARRAY_UW -> { - correct=array.array!=null && array.array.all { it in 0..65535 } + correct=array.array!=null && array.array.all { (it.integer!=null && it.integer in 0..65535) || it.pointerOf!=null} } DataType.ARRAY_W -> { - correct=array.array!=null && array.array.all { it in -32768..32767 } + correct=array.array!=null && array.array.all { it.integer!=null && it.integer in -32768..32767 } } DataType.ARRAY_F -> correct = array.doubleArray!=null else -> throw AstException("invalid array type $type") @@ -1123,7 +1118,7 @@ private class AstChecker(private val namespace: INameScope, DataType.BYTE -> sourceDatatype==DataType.BYTE DataType.UBYTE -> sourceDatatype==DataType.UBYTE DataType.WORD -> sourceDatatype==DataType.BYTE || sourceDatatype==DataType.UBYTE || sourceDatatype==DataType.WORD - DataType.UWORD -> sourceDatatype in setOf(DataType.UBYTE, DataType.UWORD, DataType.STR, DataType.STR_S) || sourceDatatype in ArrayDatatypes + DataType.UWORD -> sourceDatatype==DataType.UBYTE || sourceDatatype==DataType.UWORD DataType.FLOAT -> sourceDatatype in NumericDatatypes DataType.STR -> sourceDatatype==DataType.STR DataType.STR_S -> sourceDatatype==DataType.STR_S diff --git a/compiler/src/prog8/compiler/Compiler.kt b/compiler/src/prog8/compiler/Compiler.kt index 2b1367ee2..0b45c7447 100644 --- a/compiler/src/prog8/compiler/Compiler.kt +++ b/compiler/src/prog8/compiler/Compiler.kt @@ -36,8 +36,11 @@ fun Number.toHex(): String { } +data class IntegerOrPointerOf(val integer: Int?, val pointerOf: PointerOf?) + + class HeapValues { - data class HeapValue(val type: DataType, val str: String?, val array: IntArray?, val doubleArray: DoubleArray?) { + data class HeapValue(val type: DataType, val str: String?, val array: Array?, val doubleArray: DoubleArray?) { override fun equals(other: Any?): Boolean { if (this === other) return true if (javaClass != other?.javaClass) return false @@ -61,7 +64,7 @@ class HeapValues { fun size(): Int = heap.size - fun add(type: DataType, str: String): Int { + fun addString(type: DataType, str: String): Int { if (str.length > 255) throw IllegalArgumentException("string length must be 0-255") @@ -76,14 +79,14 @@ class HeapValues { return newId } - fun add(type: DataType, array: IntArray): Int { + fun addIntegerArray(type: DataType, array: Array): Int { // arrays are never shared, don't check for existing val newId = heapId++ heap[newId] = HeapValue(type, null, array, null) return newId } - fun add(type: DataType, darray: DoubleArray): Int { + fun addDoublesArray(type: DataType, darray: DoubleArray): Int { // arrays are never shared, don't check for existing val newId = heapId++ heap[newId] = HeapValue(type, null, null, darray) @@ -653,6 +656,7 @@ internal class Compiler(private val rootModule: Module, is TypecastExpression -> translate(expr) is DirectMemoryRead -> translate(expr) is DirectMemoryWrite -> translate(expr) + is PointerOf -> translate(expr) else -> { val lv = expr.constValue(namespace, heap) ?: throw CompilerException("constant expression required, not $expr") when(lv.type) { @@ -1081,12 +1085,13 @@ internal class Compiler(private val rootModule: Module, translate(assignA) translate(assignX) } - DataType.UWORD -> { + in WordDatatypes -> { translate(arg.first) prog.instr(Opcode.POP_REGAX_WORD) } + // TODO auto-converting str/float/array to their pointer value should be done by explicitly rewriting the Ast into a pointer-of expression, once that is available DataType.STR, DataType.STR_S -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGAX_WORD) } DataType.FLOAT -> { @@ -1094,7 +1099,7 @@ internal class Compiler(private val rootModule: Module, prog.instr(Opcode.POP_REGAX_WORD) } in ArrayDatatypes -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGAX_WORD) } else -> TODO("pass parameter of type $paramDt in registers AX at $callPosition") @@ -1119,8 +1124,9 @@ internal class Compiler(private val rootModule: Module, translate(arg.first) prog.instr(Opcode.POP_REGAY_WORD) } + // TODO auto-converting str/float/array to their pointer value should be done by explicitly rewriting the Ast into a pointer-of expression, once that is available DataType.STR, DataType.STR_S -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGAY_WORD) } DataType.FLOAT -> { @@ -1128,7 +1134,7 @@ internal class Compiler(private val rootModule: Module, prog.instr(Opcode.POP_REGAY_WORD) } in ArrayDatatypes -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGAY_WORD) } else -> TODO("pass parameter of type $paramDt in registers AY at $callPosition") @@ -1153,12 +1159,13 @@ internal class Compiler(private val rootModule: Module, translate(assignX) translate(assignY) } - DataType.UWORD -> { + in WordDatatypes -> { translate(arg.first) prog.instr(Opcode.POP_REGXY_WORD) } + // TODO auto-converting str/float/array to their pointer value should be done by explicitly rewriting the Ast into a pointer-of expression, once that is available DataType.STR, DataType.STR_S -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGXY_WORD) } DataType.FLOAT -> { @@ -1166,7 +1173,7 @@ internal class Compiler(private val rootModule: Module, prog.instr(Opcode.POP_REGXY_WORD) } in ArrayDatatypes -> { - pushStringAddress(arg.first, false) + pushHeapVarAddress(arg.first, false) prog.instr(Opcode.POP_REGXY_WORD) } else -> TODO("pass parameter of type $paramDt in registers XY at $callPosition") @@ -1524,7 +1531,7 @@ internal class Compiler(private val rootModule: Module, when (valueDt) { DataType.UBYTE -> prog.instr(Opcode.CAST_UB_TO_UW) DataType.BYTE -> prog.instr(Opcode.CAST_B_TO_UW) - DataType.STR, DataType.STR_S -> pushStringAddress(stmt.value, true) + DataType.STR, DataType.STR_S -> pushHeapVarAddress(stmt.value, true) DataType.ARRAY_B, DataType.ARRAY_UB, DataType.ARRAY_W, DataType.ARRAY_UW, DataType.ARRAY_F -> { if (stmt.value is IdentifierReference) { val vardecl = (stmt.value as IdentifierReference).targetStatement(namespace) as VarDecl @@ -1548,7 +1555,7 @@ internal class Compiler(private val rootModule: Module, } in StringDatatypes -> throw CompilerException("incompatible data types valueDt=$valueDt targetDt=$targetDt at $stmt") in ArrayDatatypes -> throw CompilerException("incompatible data types valueDt=$valueDt targetDt=$targetDt at $stmt") - else -> throw CompilerException("weird/unknonwn targetdt") + else -> throw CompilerException("weird/unknown targetdt") } } @@ -1560,9 +1567,9 @@ internal class Compiler(private val rootModule: Module, popValueIntoTarget(assignTarget, datatype) } - private fun pushStringAddress(value: IExpression, removeLastOpcode: Boolean) { + private fun pushHeapVarAddress(value: IExpression, removeLastOpcode: Boolean) { when (value) { - is LiteralValue -> throw CompilerException("can only push address of string that is a variable on the heap") + is LiteralValue -> throw CompilerException("can only push address of string or array (value on the heap)") is IdentifierReference -> { val vardecl = value.targetStatement(namespace) as VarDecl if(removeLastOpcode) prog.removeLastInstruction() @@ -2163,6 +2170,18 @@ internal class Compiler(private val rootModule: Module, } } + private fun translate(ptrof: PointerOf) { + val target = ptrof.identifier.targetStatement(namespace) as VarDecl + if(target.datatype in ArrayDatatypes || target.datatype in StringDatatypes|| target.datatype==DataType.FLOAT) { + pushHeapVarAddress(ptrof.identifier, false) + } + else if(target.datatype==DataType.FLOAT) { + pushFloatAddress(ptrof.identifier) + } + else + throw CompilerException("cannot take memory pointer $ptrof") + } + private fun translateAsmInclude(args: List, importedFrom: Path) { val scopeprefix = if(args[1].str!!.isNotBlank()) "${args[1].str}\t.proc\n" else "" val scopeprefixEnd = if(args[1].str!!.isNotBlank()) "\t.pend\n" else "" diff --git a/compiler/src/prog8/compiler/target/c64/AsmGen.kt b/compiler/src/prog8/compiler/target/c64/AsmGen.kt index 0352010a9..c83bc3de7 100644 --- a/compiler/src/prog8/compiler/target/c64/AsmGen.kt +++ b/compiler/src/prog8/compiler/target/c64/AsmGen.kt @@ -359,20 +359,25 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram, private fun makeArrayFillDataUnsigned(value: Value): List { val array = heap.get(value.heapId).array!! - return if (value.type == DataType.ARRAY_UB || value.type == DataType.ARRAY_UW) - array.map { "$"+it.toString(16).padStart(2, '0') } + if(value.type==DataType.ARRAY_UB) { + TODO("deal with byte array") + //return array.map { "$"+it.toString(16).padStart(2, '0') } + } else if(value.type==DataType.ARRAY_UW) { + TODO("deal with pointerto") + } else throw AssemblyError("invalid arrayspec type") } private fun makeArrayFillDataSigned(value: Value): List { val array = heap.get(value.heapId).array!! + // note: array of signed value can never contain pointer-to type, so simply process values as being all integers return if (value.type == DataType.ARRAY_B || value.type == DataType.ARRAY_W) { array.map { - if(it>=0) - "$"+it.toString(16).padStart(2, '0') + if(it.integer!!>=0) + "$"+it.integer.toString(16).padStart(2, '0') else - "-$"+abs(it).toString(16).padStart(2, '0') + "-$"+abs(it.integer).toString(16).padStart(2, '0') } } else throw AssemblyError("invalid arrayspec type") @@ -923,23 +928,21 @@ class AsmGen(val options: CompilationOptions, val program: IntermediateProgram, if(mulIns.opcode == Opcode.MUL_B || mulIns.opcode==Opcode.MUL_UB) { if(amount in setOf(0,1,2,4,8,16,32,64,128,256)) - throw AssemblyError("multiplication by power of 2 should have been converted into a left shift instruction already") - + printWarning("multiplication by power of 2 should have been optimized into a left shift instruction: $mulIns $amount") if(amount in setOf(3,5,6,7,9,10,11,12,13,14,15,20,25,40)) return " jsr math.mul_byte_$amount" - if(mulIns.opcode == Opcode.MUL_B && amount in setOf(-3,-5,-6,-7,-9,-10,-11,-12,-13,-14,-15,-20,-25,-40)) return " jsr prog8_lib.neg_b | jsr math.mul_byte_${-amount}" } else if(mulIns.opcode == Opcode.MUL_UW) { if(amount in setOf(0,1,2,4,8,16,32,64,128,256)) - throw AssemblyError("multiplication by power of 2 should have been converted into a left shift instruction already") + printWarning("multiplication by power of 2 should have been optimized into a left shift instruction: $mulIns $amount") if(amount in setOf(3,5,6,7,9,10,12,15,20,25,40)) return " jsr math.mul_word_$amount" } else if(mulIns.opcode == Opcode.MUL_W) { if(amount in setOf(0,1,2,4,8,16,32,64,128,256)) - throw AssemblyError("multiplication by power of 2 should have been converted into a left shift instruction already") + printWarning("multiplication by power of 2 should have been optimized into a left shift instruction: $mulIns $amount") if(amount in setOf(3,5,6,7,9,10,12,15,20,25,40)) return " jsr math.mul_word_$amount" if(amount in setOf(-3,-5,-6,-7,-9,-10,-12,-15,-20,-25,-40)) diff --git a/compiler/src/prog8/functions/BuiltinFunctions.kt b/compiler/src/prog8/functions/BuiltinFunctions.kt index 45c918a59..4e5510b1e 100644 --- a/compiler/src/prog8/functions/BuiltinFunctions.kt +++ b/compiler/src/prog8/functions/BuiltinFunctions.kt @@ -245,7 +245,12 @@ private fun collectionArgOutputNumber(args: List, position: Positio if(iterable.heapId==null) throw FatalAstException("iterable value should be on the heap") val array = heap.get(iterable.heapId).array ?: throw SyntaxError("function expects an iterable type", position) - function(array.map { it.toDouble() }) + function(array.map { + if(it.integer!=null) + it.integer.toDouble() + else + throw FatalAstException("cannot perform function over array that contains other values besides constant integers") + }) } } } @@ -266,7 +271,12 @@ private fun collectionArgOutputBoolean(args: List, position: Positi function(constants.map { it!!.toDouble() }) } else { val array = heap.get(iterable.heapId!!).array ?: throw SyntaxError("function requires array argument", position) - function(array.map { it.toDouble() }) + function(array.map { + if(it.integer!=null) + it.integer.toDouble() + else + throw FatalAstException("cannot perform function over array that contains other values besides constant integers") + }) } return LiteralValue.fromBoolean(result, position) } @@ -298,7 +308,12 @@ private fun builtinAvg(args: List, position: Position, namespace:IN } else { val array = heap.get(iterable.heapId!!).array ?: throw SyntaxError("avg requires array argument", position) - array.average() + if(array.all {it.integer!=null}) { + array.map { it.integer!! }.average() + } else { + throw ExpressionError("cannot avg() over array that does not only contain constant integer values", position) + } + // TODO what about avg() on floating point array variable! } return numericLiteral(result, args[0].position) } diff --git a/compiler/src/prog8/optimizing/ConstantFolding.kt b/compiler/src/prog8/optimizing/ConstantFolding.kt index 6c5de45f7..f45f1f631 100644 --- a/compiler/src/prog8/optimizing/ConstantFolding.kt +++ b/compiler/src/prog8/optimizing/ConstantFolding.kt @@ -3,6 +3,7 @@ package prog8.optimizing import prog8.ast.* import prog8.compiler.CompilerException import prog8.compiler.HeapValues +import prog8.compiler.IntegerOrPointerOf import prog8.compiler.target.c64.FLOAT_MAX_NEGATIVE import prog8.compiler.target.c64.FLOAT_MAX_POSITIVE import kotlin.math.floor @@ -69,8 +70,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV } else -> {} } - val fillArray = IntArray(size) { fillvalue } - val heapId = heap.add(decl.datatype, fillArray) + val heapId = heap.addIntegerArray(decl.datatype, Array(size) { IntegerOrPointerOf(fillvalue, null) }) decl.value = LiteralValue(decl.datatype, heapId = heapId, position = litval?.position ?: decl.position) } } @@ -82,8 +82,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV if(fillvalue< FLOAT_MAX_NEGATIVE || fillvalue> FLOAT_MAX_POSITIVE) errors.add(ExpressionError("float value overflow", litval?.position ?: decl.position)) else { - val fillArray = DoubleArray(size) { fillvalue } - val heapId = heap.add(decl.datatype, fillArray) + val heapId = heap.addDoublesArray(decl.datatype, DoubleArray(size) { fillvalue }) decl.value = LiteralValue(decl.datatype, heapId = heapId, position = litval?.position ?: decl.position) } } @@ -112,7 +111,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV DataType.ARRAY_F -> { if(array.array!=null) { // convert a non-float array to floats - val doubleArray = array.array.map { it.toDouble() }.toDoubleArray() + val doubleArray = array.array.map { it.integer!!.toDouble() }.toDoubleArray() heap.update(heapId, HeapValues.HeapValue(DataType.ARRAY_F, null, null, doubleArray)) decl.value = LiteralValue(decl.datatype, heapId = heapId, position = litval.position) } @@ -534,7 +533,7 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV if(literalValue.strvalue(heap).length !in 1..255) addError(ExpressionError("string literal length must be between 1 and 255", literalValue.position)) else { - val heapId = heap.add(literalValue.type, literalValue.strvalue(heap)) // TODO: we don't know the actual string type yet, STR != STR_S etc... + val heapId = heap.addString(literalValue.type, literalValue.strvalue(heap)) // TODO: we don't know the actual string type yet, STR != STR_S etc... val newValue = LiteralValue(literalValue.type, heapId = heapId, position = literalValue.position) return super.process(newValue) } @@ -547,13 +546,20 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV private fun moveArrayToHeap(arraylit: LiteralValue): LiteralValue { val array: Array = arraylit.arrayvalue!!.map { it.process(this) }.toTypedArray() - val allElementsAreConstant = array.fold(true) { c, expr-> c and (expr is LiteralValue)} - if(!allElementsAreConstant) { - addError(ExpressionError("array literal can contain only constant values", arraylit.position)) + val allElementsAreConstantOrPointerOf = array.fold(true) { c, expr-> c and (expr is LiteralValue || expr is PointerOf)} + if(!allElementsAreConstantOrPointerOf) { + addError(ExpressionError("array literal can only consist of constant primitive numerical values or memory pointers", arraylit.position)) return arraylit + } else if(array.any {it is PointerOf}) { + val arrayDt = DataType.UWORD + val intArrayWithPointers = mutableListOf() + // TODO FILL THIS ARRAY + val heapId = heap.addIntegerArray(DataType.UWORD, intArrayWithPointers.toTypedArray()) + return LiteralValue(arrayDt, heapId = heapId, position = arraylit.position) } else { + // array is only constant numerical values val valuesInArray = array.map { it.constValue(namespace, heap)!!.asNumericValue!! } - val integerArray = valuesInArray.map{it.toInt()}.toIntArray() + val integerArray = valuesInArray.map{ it.toInt() } val doubleArray = valuesInArray.map{it.toDouble()}.toDoubleArray() val typesInArray: Set = array.mapNotNull { it.resultingDatatype(namespace, heap) }.toSet() @@ -587,8 +593,8 @@ class ConstantFolding(private val namespace: INameScope, private val heap: HeapV DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, - DataType.ARRAY_W -> heap.add(arrayDt, integerArray) - DataType.ARRAY_F -> heap.add(arrayDt, doubleArray) + DataType.ARRAY_W -> heap.addIntegerArray(arrayDt, integerArray.map { IntegerOrPointerOf(it, null) }.toTypedArray()) + DataType.ARRAY_F -> heap.addDoublesArray(arrayDt, doubleArray) else -> throw CompilerException("invalid arrayspec type") } return LiteralValue(arrayDt, heapId = heapId, position = arraylit.position) diff --git a/compiler/src/prog8/stackvm/Program.kt b/compiler/src/prog8/stackvm/Program.kt index 8fdcb3b4a..44541cba6 100644 --- a/compiler/src/prog8/stackvm/Program.kt +++ b/compiler/src/prog8/stackvm/Program.kt @@ -2,6 +2,7 @@ package prog8.stackvm import prog8.ast.* import prog8.compiler.HeapValues +import prog8.compiler.IntegerOrPointerOf import prog8.compiler.intermediate.* import java.io.File import java.util.* @@ -87,17 +88,17 @@ class Program (val name: String, } heapvalues.sortedBy { it.first }.forEach { when(it.second) { - DataType.STR, DataType.STR_S -> heap.add(it.second, unescape(it.third.substring(1, it.third.length-1), Position("", 0, 0, 0))) + DataType.STR, DataType.STR_S -> heap.addString(it.second, unescape(it.third.substring(1, it.third.length-1), Position("", 0, 0, 0))) DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> { val numbers = it.third.substring(1, it.third.length-1).split(',') - val intarray = numbers.map{number->number.trim().toInt()}.toIntArray() - heap.add(it.second, intarray) + val intarray = numbers.map{number->IntegerOrPointerOf(number.trim().toInt(), null)}.toTypedArray() + heap.addIntegerArray(it.second, intarray) } DataType.ARRAY_F -> { val numbers = it.third.substring(1, it.third.length-1).split(',') val doublearray = numbers.map{number->number.trim().toDouble()}.toDoubleArray() - heap.add(it.second, doublearray) + heap.addDoublesArray(it.second, doublearray) } in NumericDatatypes -> throw VmExecutionException("invalid heap value type ${it.second}") else -> throw VmExecutionException("weird datatype") diff --git a/compiler/src/prog8/stackvm/StackVm.kt b/compiler/src/prog8/stackvm/StackVm.kt index 225eee64f..328e1c5e5 100644 --- a/compiler/src/prog8/stackvm/StackVm.kt +++ b/compiler/src/prog8/stackvm/StackVm.kt @@ -2,6 +2,7 @@ package prog8.stackvm import prog8.ast.* import prog8.compiler.HeapValues +import prog8.compiler.IntegerOrPointerOf import prog8.compiler.intermediate.Instruction import prog8.compiler.intermediate.Opcode import prog8.compiler.intermediate.Value @@ -1602,8 +1603,8 @@ class StackVm(private var traceOutputFile: String?) { // get indexed byte element from the arrayspec val array = heap.get(variable.heapId) when (array.type) { - DataType.ARRAY_UB -> Value(DataType.UBYTE, array.array!![index]) - DataType.ARRAY_B -> Value(DataType.BYTE, array.array!![index]) + DataType.ARRAY_UB -> Value(DataType.UBYTE, array.array!![index].integer!!) + DataType.ARRAY_B -> Value(DataType.BYTE, array.array!![index].integer!!) DataType.STR, DataType.STR_S -> Value(DataType.UBYTE, Petscii.encodePetscii(array.str!![index].toString(), true)[0]) else -> throw VmExecutionException("not a proper array/string variable with byte elements") } @@ -1634,8 +1635,14 @@ class StackVm(private var traceOutputFile: String?) { // get indexed word element from the arrayspec val array = heap.get(variable.heapId) when(array.type){ - DataType.ARRAY_UW -> Value(DataType.UWORD, array.array!![index]) - DataType.ARRAY_W -> Value(DataType.WORD, array.array!![index]) + DataType.ARRAY_UW -> { + val value = array.array!![index] + if(value.integer!=null) + Value(DataType.UWORD, value.integer) + else + TODO("deal with pointerTo $value") + } + DataType.ARRAY_W -> Value(DataType.WORD, array.array!![index].integer!!) else -> throw VmExecutionException("not a proper arrayspec var with word elements") } } @@ -1701,8 +1708,8 @@ class StackVm(private var traceOutputFile: String?) { // set indexed byte element in the arrayspec val array = heap.get(variable.heapId) when (array.type) { - DataType.ARRAY_UB -> array.array!![index] = value.integerValue() - DataType.ARRAY_B -> array.array!![index] = value.integerValue() + DataType.ARRAY_UB -> array.array!![index] = IntegerOrPointerOf(value.integerValue(), null) + DataType.ARRAY_B -> array.array!![index] = IntegerOrPointerOf(value.integerValue(), null) DataType.STR, DataType.STR_S -> { val chars = array.str!!.toCharArray() val ps = Petscii.decodePetscii(listOf(value.integerValue().toShort()), true)[0] @@ -1749,8 +1756,8 @@ class StackVm(private var traceOutputFile: String?) { // set indexed word element in the arrayspec val array = heap.get(variable.heapId) when (array.type) { - DataType.ARRAY_UW -> array.array!![index] = value.integerValue() - DataType.ARRAY_W -> array.array!![index] = value.integerValue() + DataType.ARRAY_UW -> array.array!![index] = IntegerOrPointerOf(value.integerValue(), null) + DataType.ARRAY_W -> array.array!![index] = IntegerOrPointerOf(value.integerValue(), null) else -> throw VmExecutionException("not a proper arrayspec var with word elements") } } @@ -2051,92 +2058,130 @@ class StackVm(private var traceOutputFile: String?) { Syscall.FUNC_MAX_UB -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.max() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.max() ?: 0 evalstack.push(Value(DataType.UBYTE, result)) } Syscall.FUNC_MAX_B -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.max() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.max() ?: 0 evalstack.push(Value(DataType.BYTE, result)) } Syscall.FUNC_MAX_UW -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.max() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.max() ?: 0 evalstack.push(Value(DataType.UWORD, result)) } Syscall.FUNC_MAX_W -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.max() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.max() ?: 0 evalstack.push(Value(DataType.WORD, result)) } Syscall.FUNC_MAX_F -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.max() ?: 0 + // TODO CHECK max(floatarray) correctness + val result = value.doubleArray!!.max() ?: 0.0 evalstack.push(Value(DataType.FLOAT, result)) } Syscall.FUNC_MIN_UB -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.min() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.min() ?: 0 evalstack.push(Value(DataType.UBYTE, result)) } Syscall.FUNC_MIN_B -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.min() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.min() ?: 0 evalstack.push(Value(DataType.BYTE, result)) } Syscall.FUNC_MIN_UW -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.min() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.min() ?: 0 evalstack.push(Value(DataType.UWORD, result)) } Syscall.FUNC_MIN_W -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.min() ?: 0 + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + val result = value.array.map{it.integer!!}.min() ?: 0 evalstack.push(Value(DataType.WORD, result)) } Syscall.FUNC_MIN_F -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - val result = value.array!!.min() ?: 0 + // TODO check min(floatarray) correctness + val result = value.doubleArray!!.min() ?: 0.0 evalstack.push(Value(DataType.FLOAT, result)) } - Syscall.FUNC_AVG_UB, Syscall.FUNC_AVG_B, Syscall.FUNC_AVG_UW, Syscall.FUNC_AVG_W, Syscall.FUNC_AVG_F -> { + Syscall.FUNC_AVG_UB, Syscall.FUNC_AVG_B, Syscall.FUNC_AVG_UW, Syscall.FUNC_AVG_W -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.FLOAT, value.array!!.average())) + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + evalstack.push(Value(DataType.FLOAT, value.array.map{it.integer!!}.average())) + } + Syscall.FUNC_AVG_F -> { + val iterable = evalstack.pop() + val value = heap.get(iterable.heapId) + // TODO check avg(floatarray) correctness + evalstack.push(Value(DataType.FLOAT, value.doubleArray!!.average())) } Syscall.FUNC_SUM_UB -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.UWORD, value.array!!.sum())) + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + evalstack.push(Value(DataType.UWORD, value.array.map{it.integer!!}.sum())) } Syscall.FUNC_SUM_B -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.WORD, value.array!!.sum())) + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + evalstack.push(Value(DataType.WORD, value.array.map{it.integer!!}.sum())) } - Syscall.FUNC_SUM_UW, Syscall.FUNC_SUM_W, Syscall.FUNC_SUM_F -> { + Syscall.FUNC_SUM_UW, Syscall.FUNC_SUM_W -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.FLOAT, value.array!!.sum())) + if(value.array!!.any{it.integer==null}) + throw VmExecutionException("cannot deal with PointerTo value in array $value") + evalstack.push(Value(DataType.FLOAT, value.array.map{it.integer!!}.sum())) + } + Syscall.FUNC_SUM_F -> { + // TODO check sum(floatarray) correctness + val iterable = evalstack.pop() + val value = heap.get(iterable.heapId) + evalstack.push(Value(DataType.FLOAT, value.doubleArray!!.sum())) } Syscall.FUNC_ANY_B, Syscall.FUNC_ANY_W, Syscall.FUNC_ANY_F -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.UBYTE, if (value.array!!.any { v -> v != 0 }) 1 else 0)) + evalstack.push(Value(DataType.UBYTE, if (value.array!!.any { v -> v.pointerOf!=null || (v.integer!=null && v.integer != 0) }) 1 else 0)) } Syscall.FUNC_ALL_B, Syscall.FUNC_ALL_W, Syscall.FUNC_ALL_F -> { val iterable = evalstack.pop() val value = heap.get(iterable.heapId) - evalstack.push(Value(DataType.UBYTE, if (value.array!!.all { v -> v != 0 }) 1 else 0)) + evalstack.push(Value(DataType.UBYTE, if (value.array!!.all { v -> v.pointerOf!=null || (v.integer!=null && v.integer != 0) }) 1 else 0)) } Syscall.FUNC_MEMCOPY -> { val numbytes = evalstack.pop().integerValue() diff --git a/examples/test.p8 b/examples/test.p8 index 429a5be08..99b4f68f2 100644 --- a/examples/test.p8 +++ b/examples/test.p8 @@ -1,35 +1,48 @@ %zeropage basicsafe -%option enable_floats - -%import c64flt ~ main { sub start() { - ubyte ub='^' - ubyte ub2=7 - uword uw=2 - uword uw2=5 - float fl=2.3 - float fl2=20 + + ; TODO what about avg() on floating point array variable! - fl = (ub as float) ** 4 - fl = 2.3 - fl = fl ** 20.0 - c64flt.print_f(fl) - c64.CHROUT('\n') + ubyte[3] array1 + ubyte[3] array2 + ubyte[3] array3 - fl = 2.3 - fl = fl ** fl2 - c64flt.print_f(fl) - c64.CHROUT('\n') + str string1="hello" + str string2="bye" - fl = 2.3 - fl **=20.0 - c64flt.print_f(fl) - c64.CHROUT('\n') + uword pointer = &array1 + byte bt + + pointer = &array2 + pointer = &string1 + + uword[4] pointers = [&array1, &array2, &string1, &string2] ; @todo make it possible to initialize array with pointers + + ;ptrsubasm("moet werken") ; @todo rewrite ast into pointer-of expression (and remove special cases from Compiler) + ;pointersub("moet werken") ; @todo rewrite ast into pointer-of expression (and remove special cases from Compiler) + ;myprintasm("moet werken3") ; @todo rewrite ast into pointer-of expression (and remove special cases from Compiler) + + ptrsubasm(&array1) + ptrsubasm(&string1) + pointersub(&array1) + pointersub(&string1) } + sub pointersub(uword arg) { + A=lsb(arg) + } + + asmsub ptrsubasm(uword arg @ AY) -> clobbers() -> () { + A=4 + } + + asmsub myprintasm(str arg @ AY) -> clobbers() -> () { + A=4 + } + } diff --git a/parser/antlr/prog8.g4 b/parser/antlr/prog8.g4 index b66a5d664..1c7bff733 100644 --- a/parser/antlr/prog8.g4 +++ b/parser/antlr/prog8.g4 @@ -154,6 +154,7 @@ expression : | scoped_identifier | arrayindexed | directmemory + | pointerof | expression typecast | '(' expression ')' ; @@ -166,6 +167,8 @@ arrayindexed : scoped_identifier arrayspec ; directmemory : '@' '(' expression ')'; +pointerof : '&' scoped_identifier ; + functioncall : scoped_identifier '(' expression_list? ')' ; diff --git a/parser/src/prog8/parser/prog8Lexer.java b/parser/src/prog8/parser/prog8Lexer.java index 908fc5267..11e4a1529 100644 --- a/parser/src/prog8/parser/prog8Lexer.java +++ b/parser/src/prog8/parser/prog8Lexer.java @@ -1,4 +1,4 @@ -// Generated from ./parser/antlr/prog8.g4 by ANTLR 4.7.2 +// Generated from prog8.g4 by ANTLR 4.7.2 package prog8.parser; diff --git a/parser/src/prog8/parser/prog8Parser.java b/parser/src/prog8/parser/prog8Parser.java index 420ebe1ef..457def31d 100644 --- a/parser/src/prog8/parser/prog8Parser.java +++ b/parser/src/prog8/parser/prog8Parser.java @@ -1,4 +1,4 @@ -// Generated from ./parser/antlr/prog8.g4 by ANTLR 4.7.2 +// Generated from prog8.g4 by ANTLR 4.7.2 package prog8.parser; @@ -44,25 +44,25 @@ public class prog8Parser extends Parser { 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_typecast = 20, RULE_arrayindexed = 21, RULE_directmemory = 22, - RULE_functioncall = 23, RULE_functioncall_stmt = 24, RULE_expression_list = 25, - RULE_returnstmt = 26, RULE_breakstmt = 27, RULE_continuestmt = 28, RULE_identifier = 29, - RULE_scoped_identifier = 30, RULE_register = 31, RULE_registerorpair = 32, - RULE_statusregister = 33, RULE_integerliteral = 34, RULE_wordsuffix = 35, - RULE_booleanliteral = 36, RULE_arrayliteral = 37, RULE_stringliteral = 38, - RULE_charliteral = 39, RULE_floatliteral = 40, RULE_literalvalue = 41, - RULE_inlineasm = 42, RULE_subroutine = 43, RULE_sub_return_part = 44, - RULE_statement_block = 45, RULE_sub_params = 46, RULE_sub_returns = 47, - RULE_asmsubroutine = 48, RULE_asmsub_address = 49, RULE_asmsub_params = 50, - RULE_asmsub_param = 51, RULE_clobber = 52, RULE_asmsub_returns = 53, RULE_asmsub_return = 54, - RULE_if_stmt = 55, RULE_else_part = 56, RULE_branch_stmt = 57, RULE_branchcondition = 58, - RULE_forloop = 59, RULE_whileloop = 60, RULE_repeatloop = 61; + RULE_pointerof = 23, RULE_functioncall = 24, RULE_functioncall_stmt = 25, + RULE_expression_list = 26, RULE_returnstmt = 27, RULE_breakstmt = 28, + RULE_continuestmt = 29, RULE_identifier = 30, RULE_scoped_identifier = 31, + RULE_register = 32, RULE_registerorpair = 33, RULE_statusregister = 34, + RULE_integerliteral = 35, RULE_wordsuffix = 36, RULE_booleanliteral = 37, + RULE_arrayliteral = 38, RULE_stringliteral = 39, RULE_charliteral = 40, + RULE_floatliteral = 41, RULE_literalvalue = 42, RULE_inlineasm = 43, RULE_subroutine = 44, + RULE_sub_return_part = 45, RULE_statement_block = 46, RULE_sub_params = 47, + RULE_sub_returns = 48, RULE_asmsubroutine = 49, RULE_asmsub_address = 50, + RULE_asmsub_params = 51, RULE_asmsub_param = 52, RULE_clobber = 53, RULE_asmsub_returns = 54, + RULE_asmsub_return = 55, RULE_if_stmt = 56, RULE_else_part = 57, RULE_branch_stmt = 58, + RULE_branchcondition = 59, RULE_forloop = 60, RULE_whileloop = 61, RULE_repeatloop = 62; private static String[] makeRuleNames() { return new String[] { "module", "modulestatement", "block", "statement", "labeldef", "unconditionaljump", "directive", "directivearg", "vardecl", "varinitializer", "constdecl", "memoryvardecl", "datatype", "arrayspec", "assignment", "assign_targets", "augassignment", "assign_target", "postincrdecr", "expression", "typecast", - "arrayindexed", "directmemory", "functioncall", "functioncall_stmt", + "arrayindexed", "directmemory", "pointerof", "functioncall", "functioncall_stmt", "expression_list", "returnstmt", "breakstmt", "continuestmt", "identifier", "scoped_identifier", "register", "registerorpair", "statusregister", "integerliteral", "wordsuffix", "booleanliteral", "arrayliteral", "stringliteral", @@ -188,12 +188,12 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(128); + setState(130); _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(126); + setState(128); _errHandler.sync(this); switch (_input.LA(1)) { case T__0: @@ -208,13 +208,13 @@ public class prog8Parser extends Parser { case T__11: case T__12: { - setState(124); + setState(126); modulestatement(); } break; case EOL: { - setState(125); + setState(127); match(EOL); } break; @@ -222,11 +222,11 @@ public class prog8Parser extends Parser { throw new NoViableAltException(this); } } - setState(130); + setState(132); _errHandler.sync(this); _la = _input.LA(1); } - setState(131); + setState(133); match(EOF); } } @@ -258,7 +258,7 @@ public class prog8Parser extends Parser { ModulestatementContext _localctx = new ModulestatementContext(_ctx, getState()); enterRule(_localctx, 2, RULE_modulestatement); try { - setState(135); + setState(137); _errHandler.sync(this); switch (_input.LA(1)) { case T__3: @@ -273,14 +273,14 @@ public class prog8Parser extends Parser { case T__12: enterOuterAlt(_localctx, 1); { - setState(133); + setState(135); directive(); } break; case T__0: enterOuterAlt(_localctx, 2); { - setState(134); + setState(136); block(); } break; @@ -323,23 +323,23 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(137); + setState(139); match(T__0); - setState(138); - identifier(); setState(140); + identifier(); + setState(142); _errHandler.sync(this); _la = _input.LA(1); if (((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) { { - setState(139); + setState(141); integerliteral(); } } - setState(142); + setState(144); statement_block(); - setState(143); + setState(145); match(EOL); } } @@ -431,160 +431,160 @@ public class prog8Parser extends Parser { StatementContext _localctx = new StatementContext(_ctx, getState()); enterRule(_localctx, 6, RULE_statement); try { - setState(167); + setState(169); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,4,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(145); + setState(147); directive(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(146); + setState(148); varinitializer(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(147); + setState(149); vardecl(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(148); + setState(150); constdecl(); } break; case 5: enterOuterAlt(_localctx, 5); { - setState(149); + setState(151); memoryvardecl(); } break; case 6: enterOuterAlt(_localctx, 6); { - setState(150); + setState(152); assignment(); } break; case 7: enterOuterAlt(_localctx, 7); { - setState(151); + setState(153); augassignment(); } break; case 8: enterOuterAlt(_localctx, 8); { - setState(152); + setState(154); unconditionaljump(); } break; case 9: enterOuterAlt(_localctx, 9); { - setState(153); + setState(155); postincrdecr(); } break; case 10: enterOuterAlt(_localctx, 10); { - setState(154); + setState(156); functioncall_stmt(); } break; case 11: enterOuterAlt(_localctx, 11); { - setState(155); + setState(157); if_stmt(); } break; case 12: enterOuterAlt(_localctx, 12); { - setState(156); + setState(158); branch_stmt(); } break; case 13: enterOuterAlt(_localctx, 13); { - setState(157); + setState(159); subroutine(); } break; case 14: enterOuterAlt(_localctx, 14); { - setState(158); + setState(160); asmsubroutine(); } break; case 15: enterOuterAlt(_localctx, 15); { - setState(159); + setState(161); inlineasm(); } break; case 16: enterOuterAlt(_localctx, 16); { - setState(160); + setState(162); returnstmt(); } break; case 17: enterOuterAlt(_localctx, 17); { - setState(161); + setState(163); forloop(); } break; case 18: enterOuterAlt(_localctx, 18); { - setState(162); + setState(164); whileloop(); } break; case 19: enterOuterAlt(_localctx, 19); { - setState(163); + setState(165); repeatloop(); } break; case 20: enterOuterAlt(_localctx, 20); { - setState(164); + setState(166); breakstmt(); } break; case 21: enterOuterAlt(_localctx, 21); { - setState(165); + setState(167); continuestmt(); } break; case 22: enterOuterAlt(_localctx, 22); { - setState(166); + setState(168); labeldef(); } break; @@ -617,9 +617,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(169); + setState(171); identifier(); - setState(170); + setState(172); match(T__1); } } @@ -653,22 +653,22 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(172); + setState(174); match(T__2); - setState(175); + setState(177); _errHandler.sync(this); switch (_input.LA(1)) { case DEC_INTEGER: case HEX_INTEGER: case BIN_INTEGER: { - setState(173); + setState(175); integerliteral(); } break; case NAME: { - setState(174); + setState(176); scoped_identifier(); } break; @@ -709,7 +709,7 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(177); + setState(179); ((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)) ) { @@ -720,17 +720,17 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(189); + setState(191); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,8,_ctx) ) { case 1: { - setState(179); + setState(181); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,6,_ctx) ) { case 1: { - setState(178); + setState(180); directivearg(); } break; @@ -739,21 +739,21 @@ public class prog8Parser extends Parser { break; case 2: { - setState(181); + setState(183); directivearg(); - setState(186); + setState(188); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(182); + setState(184); match(T__13); - setState(183); + setState(185); directivearg(); } } - setState(188); + setState(190); _errHandler.sync(this); _la = _input.LA(1); } @@ -793,20 +793,20 @@ public class prog8Parser extends Parser { DirectiveargContext _localctx = new DirectiveargContext(_ctx, getState()); enterRule(_localctx, 14, RULE_directivearg); try { - setState(194); + setState(196); _errHandler.sync(this); switch (_input.LA(1)) { case STRING: enterOuterAlt(_localctx, 1); { - setState(191); + setState(193); stringliteral(); } break; case NAME: enterOuterAlt(_localctx, 2); { - setState(192); + setState(194); identifier(); } break; @@ -815,7 +815,7 @@ public class prog8Parser extends Parser { case BIN_INTEGER: enterOuterAlt(_localctx, 3); { - setState(193); + setState(195); integerliteral(); } break; @@ -858,29 +858,29 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(196); - datatype(); setState(198); + datatype(); + setState(200); _errHandler.sync(this); _la = _input.LA(1); if (_la==ZEROPAGE) { { - setState(197); + setState(199); match(ZEROPAGE); } } - setState(201); + setState(203); _errHandler.sync(this); _la = _input.LA(1); if (_la==T__24) { { - setState(200); + setState(202); arrayspec(); } } - setState(203); + setState(205); identifier(); } } @@ -914,11 +914,11 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(205); - vardecl(); - setState(206); - match(T__14); setState(207); + vardecl(); + setState(208); + match(T__14); + setState(209); expression(0); } } @@ -949,9 +949,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(209); + setState(211); match(T__15); - setState(210); + setState(212); varinitializer(); } } @@ -982,9 +982,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(212); + setState(214); match(T__16); - setState(213); + setState(215); varinitializer(); } } @@ -1013,7 +1013,7 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(215); + setState(217); _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))) != 0)) ) { _errHandler.recoverInline(this); @@ -1052,11 +1052,11 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(217); - match(T__24); - setState(218); - expression(0); setState(219); + match(T__24); + setState(220); + expression(0); + setState(221); match(T__25); } } @@ -1090,11 +1090,11 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(221); - assign_targets(); - setState(222); - match(T__14); setState(223); + assign_targets(); + setState(224); + match(T__14); + setState(225); expression(0); } } @@ -1129,21 +1129,21 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(225); + setState(227); assign_target(); - setState(230); + setState(232); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(226); + setState(228); match(T__13); - setState(227); + setState(229); assign_target(); } } - setState(232); + setState(234); _errHandler.sync(this); _la = _input.LA(1); } @@ -1181,9 +1181,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(233); + setState(235); assign_target(); - setState(234); + setState(236); ((AugassignmentContext)_localctx).operator = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__26) | (1L << T__27) | (1L << T__28) | (1L << T__29) | (1L << T__30) | (1L << T__31) | (1L << T__32) | (1L << T__33) | (1L << T__34) | (1L << T__35) | (1L << T__36))) != 0)) ) { @@ -1194,7 +1194,7 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(235); + setState(237); expression(0); } } @@ -1232,34 +1232,34 @@ public class prog8Parser extends Parser { Assign_targetContext _localctx = new Assign_targetContext(_ctx, getState()); enterRule(_localctx, 34, RULE_assign_target); try { - setState(241); + setState(243); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,13,_ctx) ) { case 1: enterOuterAlt(_localctx, 1); { - setState(237); + setState(239); register(); } break; case 2: enterOuterAlt(_localctx, 2); { - setState(238); + setState(240); scoped_identifier(); } break; case 3: enterOuterAlt(_localctx, 3); { - setState(239); + setState(241); arrayindexed(); } break; case 4: enterOuterAlt(_localctx, 4); { - setState(240); + setState(242); directmemory(); } break; @@ -1294,9 +1294,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(243); + setState(245); assign_target(); - setState(244); + setState(246); ((PostincrdecrContext)_localctx).operator = _input.LT(1); _la = _input.LA(1); if ( !(_la==T__37 || _la==T__38) ) { @@ -1352,6 +1352,9 @@ public class prog8Parser extends Parser { public DirectmemoryContext directmemory() { return getRuleContext(DirectmemoryContext.class,0); } + public PointerofContext pointerof() { + return getRuleContext(PointerofContext.class,0); + } public List EOL() { return getTokens(prog8Parser.EOL); } public TerminalNode EOL(int i) { return getToken(prog8Parser.EOL, i); @@ -1381,18 +1384,18 @@ public class prog8Parser extends Parser { int _alt; enterOuterAlt(_localctx, 1); { - setState(261); + setState(264); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,14,_ctx) ) { case 1: { - setState(247); + setState(249); functioncall(); } break; case 2: { - setState(248); + setState(250); ((ExpressionContext)_localctx).prefix = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__39) | (1L << T__40))) != 0)) ) { @@ -1403,61 +1406,67 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(249); - expression(22); + setState(251); + expression(23); } break; case 3: { - setState(250); + setState(252); ((ExpressionContext)_localctx).prefix = match(T__61); - setState(251); - expression(8); + setState(253); + expression(9); } break; case 4: { - setState(252); + setState(254); literalvalue(); } break; case 5: { - setState(253); + setState(255); register(); } break; case 6: { - setState(254); + setState(256); scoped_identifier(); } break; case 7: { - setState(255); + setState(257); arrayindexed(); } break; case 8: { - setState(256); + setState(258); directmemory(); } break; case 9: { - setState(257); - match(T__62); - setState(258); - expression(0); setState(259); + pointerof(); + } + break; + case 10: + { + setState(260); + match(T__62); + setState(261); + expression(0); + setState(262); match(T__63); } break; } _ctx.stop = _input.LT(-1); - setState(382); + setState(385); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,41,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { @@ -1465,7 +1474,7 @@ public class prog8Parser extends Parser { if ( _parseListeners!=null ) triggerExitRuleEvent(); _prevctx = _localctx; { - setState(380); + setState(383); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,40,_ctx) ) { case 1: @@ -1474,32 +1483,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(263); - if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); - setState(265); + setState(266); + if (!(precpred(_ctx, 22))) throw new FailedPredicateException(this, "precpred(_ctx, 22)"); + setState(268); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(264); + setState(267); match(EOL); } } - setState(267); + setState(270); ((ExpressionContext)_localctx).bop = match(T__41); - setState(269); + setState(272); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(268); + setState(271); match(EOL); } } - setState(271); - ((ExpressionContext)_localctx).right = expression(22); + setState(274); + ((ExpressionContext)_localctx).right = expression(23); } break; case 2: @@ -1508,19 +1517,19 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(272); - if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); - setState(274); + setState(275); + if (!(precpred(_ctx, 21))) throw new FailedPredicateException(this, "precpred(_ctx, 21)"); + setState(277); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(273); + setState(276); match(EOL); } } - setState(276); + setState(279); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__42) | (1L << T__43) | (1L << T__44))) != 0)) ) { @@ -1531,18 +1540,18 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(278); + setState(281); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(277); + setState(280); match(EOL); } } - setState(280); - ((ExpressionContext)_localctx).right = expression(21); + setState(283); + ((ExpressionContext)_localctx).right = expression(22); } break; case 3: @@ -1551,19 +1560,19 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(281); - if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); - setState(283); + setState(284); + if (!(precpred(_ctx, 20))) throw new FailedPredicateException(this, "precpred(_ctx, 20)"); + setState(286); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(282); + setState(285); match(EOL); } } - setState(285); + setState(288); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(_la==T__39 || _la==T__40) ) { @@ -1574,18 +1583,18 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(287); + setState(290); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(286); + setState(289); match(EOL); } } - setState(289); - ((ExpressionContext)_localctx).right = expression(20); + setState(292); + ((ExpressionContext)_localctx).right = expression(21); } break; case 4: @@ -1594,19 +1603,19 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(290); - if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); - setState(292); + setState(293); + if (!(precpred(_ctx, 19))) throw new FailedPredicateException(this, "precpred(_ctx, 19)"); + setState(295); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(291); + setState(294); match(EOL); } } - setState(294); + setState(297); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(_la==T__45 || _la==T__46) ) { @@ -1617,18 +1626,18 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(296); + setState(299); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(295); + setState(298); match(EOL); } } - setState(298); - ((ExpressionContext)_localctx).right = expression(19); + setState(301); + ((ExpressionContext)_localctx).right = expression(20); } break; case 5: @@ -1637,19 +1646,19 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(299); - if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); - setState(301); + setState(302); + if (!(precpred(_ctx, 18))) throw new FailedPredicateException(this, "precpred(_ctx, 18)"); + setState(304); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(300); + setState(303); match(EOL); } } - setState(303); + setState(306); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__47) | (1L << T__48) | (1L << T__49) | (1L << T__50))) != 0)) ) { @@ -1660,18 +1669,18 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(305); + setState(308); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(304); + setState(307); match(EOL); } } - setState(307); - ((ExpressionContext)_localctx).right = expression(18); + setState(310); + ((ExpressionContext)_localctx).right = expression(19); } break; case 6: @@ -1680,19 +1689,19 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(308); - if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); - setState(310); + setState(311); + if (!(precpred(_ctx, 17))) throw new FailedPredicateException(this, "precpred(_ctx, 17)"); + setState(313); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(309); + setState(312); match(EOL); } } - setState(312); + setState(315); ((ExpressionContext)_localctx).bop = _input.LT(1); _la = _input.LA(1); if ( !(_la==T__51 || _la==T__52) ) { @@ -1703,18 +1712,18 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(314); + setState(317); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(313); + setState(316); match(EOL); } } - setState(316); - ((ExpressionContext)_localctx).right = expression(17); + setState(319); + ((ExpressionContext)_localctx).right = expression(18); } break; case 7: @@ -1723,32 +1732,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(317); - if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); - setState(319); + setState(320); + if (!(precpred(_ctx, 16))) throw new FailedPredicateException(this, "precpred(_ctx, 16)"); + setState(322); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(318); + setState(321); match(EOL); } } - setState(321); + setState(324); ((ExpressionContext)_localctx).bop = match(T__53); - setState(323); + setState(326); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(322); + setState(325); match(EOL); } } - setState(325); - ((ExpressionContext)_localctx).right = expression(16); + setState(328); + ((ExpressionContext)_localctx).right = expression(17); } break; case 8: @@ -1757,32 +1766,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(326); - if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); - setState(328); + setState(329); + if (!(precpred(_ctx, 15))) throw new FailedPredicateException(this, "precpred(_ctx, 15)"); + setState(331); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(327); + setState(330); match(EOL); } } - setState(330); + setState(333); ((ExpressionContext)_localctx).bop = match(T__54); - setState(332); + setState(335); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(331); + setState(334); match(EOL); } } - setState(334); - ((ExpressionContext)_localctx).right = expression(15); + setState(337); + ((ExpressionContext)_localctx).right = expression(16); } break; case 9: @@ -1791,32 +1800,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(335); - if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); - setState(337); + setState(338); + if (!(precpred(_ctx, 14))) throw new FailedPredicateException(this, "precpred(_ctx, 14)"); + setState(340); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(336); + setState(339); match(EOL); } } - setState(339); + setState(342); ((ExpressionContext)_localctx).bop = match(T__55); - setState(341); + setState(344); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(340); + setState(343); match(EOL); } } - setState(343); - ((ExpressionContext)_localctx).right = expression(14); + setState(346); + ((ExpressionContext)_localctx).right = expression(15); } break; case 10: @@ -1825,32 +1834,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(344); - if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); - setState(346); + setState(347); + if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); + setState(349); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(345); + setState(348); match(EOL); } } - setState(348); + setState(351); ((ExpressionContext)_localctx).bop = match(T__58); - setState(350); + setState(353); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(349); + setState(352); match(EOL); } } - setState(352); - ((ExpressionContext)_localctx).right = expression(12); + setState(355); + ((ExpressionContext)_localctx).right = expression(13); } break; case 11: @@ -1859,32 +1868,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(353); - if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); - setState(355); + setState(356); + if (!(precpred(_ctx, 11))) throw new FailedPredicateException(this, "precpred(_ctx, 11)"); + setState(358); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(354); + setState(357); match(EOL); } } - setState(357); + setState(360); ((ExpressionContext)_localctx).bop = match(T__59); - setState(359); + setState(362); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(358); + setState(361); match(EOL); } } - setState(361); - ((ExpressionContext)_localctx).right = expression(11); + setState(364); + ((ExpressionContext)_localctx).right = expression(12); } break; case 12: @@ -1893,32 +1902,32 @@ public class prog8Parser extends Parser { _localctx.left = _prevctx; _localctx.left = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(362); - if (!(precpred(_ctx, 9))) throw new FailedPredicateException(this, "precpred(_ctx, 9)"); - setState(364); + setState(365); + if (!(precpred(_ctx, 10))) throw new FailedPredicateException(this, "precpred(_ctx, 10)"); + setState(367); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(363); + setState(366); match(EOL); } } - setState(366); + setState(369); ((ExpressionContext)_localctx).bop = match(T__60); - setState(368); + setState(371); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(367); + setState(370); match(EOL); } } - setState(370); - ((ExpressionContext)_localctx).right = expression(10); + setState(373); + ((ExpressionContext)_localctx).right = expression(11); } break; case 13: @@ -1927,20 +1936,20 @@ public class prog8Parser extends Parser { _localctx.rangefrom = _prevctx; _localctx.rangefrom = _prevctx; pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(371); - if (!(precpred(_ctx, 12))) throw new FailedPredicateException(this, "precpred(_ctx, 12)"); - setState(372); + setState(374); + if (!(precpred(_ctx, 13))) throw new FailedPredicateException(this, "precpred(_ctx, 13)"); + setState(375); match(T__56); - setState(373); - ((ExpressionContext)_localctx).rangeto = expression(0); setState(376); + ((ExpressionContext)_localctx).rangeto = expression(0); + setState(379); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,39,_ctx) ) { case 1: { - setState(374); + setState(377); match(T__57); - setState(375); + setState(378); ((ExpressionContext)_localctx).rangestep = expression(0); } break; @@ -1951,16 +1960,16 @@ public class prog8Parser extends Parser { { _localctx = new ExpressionContext(_parentctx, _parentState); pushNewRecursionContext(_localctx, _startState, RULE_expression); - setState(378); + setState(381); if (!(precpred(_ctx, 2))) throw new FailedPredicateException(this, "precpred(_ctx, 2)"); - setState(379); + setState(382); typecast(); } break; } } } - setState(384); + setState(387); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,41,_ctx); } @@ -1993,9 +2002,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(385); + setState(388); match(T__64); - setState(386); + setState(389); datatype(); } } @@ -2029,9 +2038,9 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(388); + setState(391); scoped_identifier(); - setState(389); + setState(392); arrayspec(); } } @@ -2062,13 +2071,13 @@ public class prog8Parser extends Parser { try { enterOuterAlt(_localctx, 1); { - setState(391); - match(T__65); - setState(392); - match(T__62); - setState(393); - expression(0); setState(394); + match(T__65); + setState(395); + match(T__62); + setState(396); + expression(0); + setState(397); match(T__63); } } @@ -2083,6 +2092,39 @@ public class prog8Parser extends Parser { return _localctx; } + public static class PointerofContext extends ParserRuleContext { + public Scoped_identifierContext scoped_identifier() { + return getRuleContext(Scoped_identifierContext.class,0); + } + public PointerofContext(ParserRuleContext parent, int invokingState) { + super(parent, invokingState); + } + @Override public int getRuleIndex() { return RULE_pointerof; } + } + + public final PointerofContext pointerof() throws RecognitionException { + PointerofContext _localctx = new PointerofContext(_ctx, getState()); + enterRule(_localctx, 46, RULE_pointerof); + try { + enterOuterAlt(_localctx, 1); + { + setState(399); + match(T__53); + setState(400); + scoped_identifier(); + } + } + catch (RecognitionException re) { + _localctx.exception = re; + _errHandler.reportError(this, re); + _errHandler.recover(this, re); + } + finally { + exitRule(); + } + return _localctx; + } + public static class FunctioncallContext extends ParserRuleContext { public Scoped_identifierContext scoped_identifier() { return getRuleContext(Scoped_identifierContext.class,0); @@ -2098,26 +2140,26 @@ public class prog8Parser extends Parser { public final FunctioncallContext functioncall() throws RecognitionException { FunctioncallContext _localctx = new FunctioncallContext(_ctx, getState()); - enterRule(_localctx, 46, RULE_functioncall); + enterRule(_localctx, 48, RULE_functioncall); int _la; try { enterOuterAlt(_localctx, 1); { - setState(396); + setState(402); scoped_identifier(); - setState(397); + setState(403); match(T__62); - setState(399); + setState(405); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__53) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { { - setState(398); + setState(404); expression_list(); } } - setState(401); + setState(407); match(T__63); } } @@ -2147,26 +2189,26 @@ public class prog8Parser extends Parser { public final Functioncall_stmtContext functioncall_stmt() throws RecognitionException { Functioncall_stmtContext _localctx = new Functioncall_stmtContext(_ctx, getState()); - enterRule(_localctx, 48, RULE_functioncall_stmt); + enterRule(_localctx, 50, RULE_functioncall_stmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(403); + setState(409); scoped_identifier(); - setState(404); + setState(410); match(T__62); - setState(406); + setState(412); _errHandler.sync(this); _la = _input.LA(1); - if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { + if ((((_la) & ~0x3f) == 0 && ((1L << _la) & ((1L << T__0) | (1L << T__24) | (1L << T__39) | (1L << T__40) | (1L << T__53) | (1L << T__61) | (1L << T__62))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__81 - 66)) | (1L << (T__82 - 66)) | (1L << (NAME - 66)) | (1L << (DEC_INTEGER - 66)) | (1L << (HEX_INTEGER - 66)) | (1L << (BIN_INTEGER - 66)) | (1L << (FLOAT_NUMBER - 66)) | (1L << (STRING - 66)) | (1L << (SINGLECHAR - 66)))) != 0)) { { - setState(405); + setState(411); expression_list(); } } - setState(408); + setState(414); match(T__63); } } @@ -2200,36 +2242,36 @@ public class prog8Parser extends Parser { public final Expression_listContext expression_list() throws RecognitionException { Expression_listContext _localctx = new Expression_listContext(_ctx, getState()); - enterRule(_localctx, 50, RULE_expression_list); + enterRule(_localctx, 52, RULE_expression_list); int _la; try { enterOuterAlt(_localctx, 1); { - setState(410); + setState(416); expression(0); - setState(418); + setState(424); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(411); + setState(417); match(T__13); - setState(413); + setState(419); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(412); + setState(418); match(EOL); } } - setState(415); + setState(421); expression(0); } } - setState(420); + setState(426); _errHandler.sync(this); _la = _input.LA(1); } @@ -2258,18 +2300,18 @@ public class prog8Parser extends Parser { public final ReturnstmtContext returnstmt() throws RecognitionException { ReturnstmtContext _localctx = new ReturnstmtContext(_ctx, getState()); - enterRule(_localctx, 52, RULE_returnstmt); + enterRule(_localctx, 54, RULE_returnstmt); try { enterOuterAlt(_localctx, 1); { - setState(421); + setState(427); match(T__66); - setState(423); + setState(429); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,46,_ctx) ) { case 1: { - setState(422); + setState(428); expression_list(); } break; @@ -2296,11 +2338,11 @@ public class prog8Parser extends Parser { public final BreakstmtContext breakstmt() throws RecognitionException { BreakstmtContext _localctx = new BreakstmtContext(_ctx, getState()); - enterRule(_localctx, 54, RULE_breakstmt); + enterRule(_localctx, 56, RULE_breakstmt); try { enterOuterAlt(_localctx, 1); { - setState(425); + setState(431); match(T__67); } } @@ -2324,11 +2366,11 @@ public class prog8Parser extends Parser { public final ContinuestmtContext continuestmt() throws RecognitionException { ContinuestmtContext _localctx = new ContinuestmtContext(_ctx, getState()); - enterRule(_localctx, 56, RULE_continuestmt); + enterRule(_localctx, 58, RULE_continuestmt); try { enterOuterAlt(_localctx, 1); { - setState(427); + setState(433); match(T__68); } } @@ -2353,11 +2395,11 @@ public class prog8Parser extends Parser { public final IdentifierContext identifier() throws RecognitionException { IdentifierContext _localctx = new IdentifierContext(_ctx, getState()); - enterRule(_localctx, 58, RULE_identifier); + enterRule(_localctx, 60, RULE_identifier); try { enterOuterAlt(_localctx, 1); { - setState(429); + setState(435); match(NAME); } } @@ -2385,28 +2427,28 @@ public class prog8Parser extends Parser { public final Scoped_identifierContext scoped_identifier() throws RecognitionException { Scoped_identifierContext _localctx = new Scoped_identifierContext(_ctx, getState()); - enterRule(_localctx, 60, RULE_scoped_identifier); + enterRule(_localctx, 62, RULE_scoped_identifier); try { int _alt; enterOuterAlt(_localctx, 1); { - setState(431); + setState(437); match(NAME); - setState(436); + setState(442); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,47,_ctx); while ( _alt!=2 && _alt!=org.antlr.v4.runtime.atn.ATN.INVALID_ALT_NUMBER ) { if ( _alt==1 ) { { { - setState(432); + setState(438); match(T__69); - setState(433); + setState(439); match(NAME); } } } - setState(438); + setState(444); _errHandler.sync(this); _alt = getInterpreter().adaptivePredict(_input,47,_ctx); } @@ -2432,12 +2474,12 @@ public class prog8Parser extends Parser { public final RegisterContext register() throws RecognitionException { RegisterContext _localctx = new RegisterContext(_ctx, getState()); - enterRule(_localctx, 62, RULE_register); + enterRule(_localctx, 64, RULE_register); int _la; try { enterOuterAlt(_localctx, 1); { - setState(439); + setState(445); _la = _input.LA(1); if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) ) { _errHandler.recoverInline(this); @@ -2469,12 +2511,12 @@ public class prog8Parser extends Parser { public final RegisterorpairContext registerorpair() throws RecognitionException { RegisterorpairContext _localctx = new RegisterorpairContext(_ctx, getState()); - enterRule(_localctx, 64, RULE_registerorpair); + enterRule(_localctx, 66, RULE_registerorpair); int _la; try { enterOuterAlt(_localctx, 1); { - setState(441); + setState(447); _la = _input.LA(1); if ( !(((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)) | (1L << (T__73 - 71)) | (1L << (T__74 - 71)) | (1L << (T__75 - 71)))) != 0)) ) { _errHandler.recoverInline(this); @@ -2506,12 +2548,12 @@ public class prog8Parser extends Parser { public final StatusregisterContext statusregister() throws RecognitionException { StatusregisterContext _localctx = new StatusregisterContext(_ctx, getState()); - enterRule(_localctx, 66, RULE_statusregister); + enterRule(_localctx, 68, RULE_statusregister); int _la; try { enterOuterAlt(_localctx, 1); { - setState(443); + setState(449); _la = _input.LA(1); if ( !(((((_la - 77)) & ~0x3f) == 0 && ((1L << (_la - 77)) & ((1L << (T__76 - 77)) | (1L << (T__77 - 77)) | (1L << (T__78 - 77)) | (1L << (T__79 - 77)))) != 0)) ) { _errHandler.recoverInline(this); @@ -2550,12 +2592,12 @@ public class prog8Parser extends Parser { public final IntegerliteralContext integerliteral() throws RecognitionException { IntegerliteralContext _localctx = new IntegerliteralContext(_ctx, getState()); - enterRule(_localctx, 68, RULE_integerliteral); + enterRule(_localctx, 70, RULE_integerliteral); int _la; try { enterOuterAlt(_localctx, 1); { - setState(445); + setState(451); ((IntegerliteralContext)_localctx).intpart = _input.LT(1); _la = _input.LA(1); if ( !(((((_la - 116)) & ~0x3f) == 0 && ((1L << (_la - 116)) & ((1L << (DEC_INTEGER - 116)) | (1L << (HEX_INTEGER - 116)) | (1L << (BIN_INTEGER - 116)))) != 0)) ) { @@ -2566,12 +2608,12 @@ public class prog8Parser extends Parser { _errHandler.reportMatch(this); consume(); } - setState(447); + setState(453); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,48,_ctx) ) { case 1: { - setState(446); + setState(452); wordsuffix(); } break; @@ -2598,11 +2640,11 @@ public class prog8Parser extends Parser { public final WordsuffixContext wordsuffix() throws RecognitionException { WordsuffixContext _localctx = new WordsuffixContext(_ctx, getState()); - enterRule(_localctx, 70, RULE_wordsuffix); + enterRule(_localctx, 72, RULE_wordsuffix); try { enterOuterAlt(_localctx, 1); { - setState(449); + setState(455); match(T__80); } } @@ -2626,12 +2668,12 @@ public class prog8Parser extends Parser { public final BooleanliteralContext booleanliteral() throws RecognitionException { BooleanliteralContext _localctx = new BooleanliteralContext(_ctx, getState()); - enterRule(_localctx, 72, RULE_booleanliteral); + enterRule(_localctx, 74, RULE_booleanliteral); int _la; try { enterOuterAlt(_localctx, 1); { - setState(451); + setState(457); _la = _input.LA(1); if ( !(_la==T__81 || _la==T__82) ) { _errHandler.recoverInline(this); @@ -2673,62 +2715,62 @@ public class prog8Parser extends Parser { public final ArrayliteralContext arrayliteral() throws RecognitionException { ArrayliteralContext _localctx = new ArrayliteralContext(_ctx, getState()); - enterRule(_localctx, 74, RULE_arrayliteral); + enterRule(_localctx, 76, RULE_arrayliteral); int _la; try { enterOuterAlt(_localctx, 1); { - setState(453); + setState(459); match(T__24); - setState(455); + setState(461); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(454); + setState(460); match(EOL); } } - setState(457); + setState(463); expression(0); - setState(465); + setState(471); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(458); + setState(464); match(T__13); - setState(460); + setState(466); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(459); + setState(465); match(EOL); } } - setState(462); + setState(468); expression(0); } } - setState(467); + setState(473); _errHandler.sync(this); _la = _input.LA(1); } - setState(469); + setState(475); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(468); + setState(474); match(EOL); } } - setState(471); + setState(477); match(T__25); } } @@ -2753,11 +2795,11 @@ public class prog8Parser extends Parser { public final StringliteralContext stringliteral() throws RecognitionException { StringliteralContext _localctx = new StringliteralContext(_ctx, getState()); - enterRule(_localctx, 76, RULE_stringliteral); + enterRule(_localctx, 78, RULE_stringliteral); try { enterOuterAlt(_localctx, 1); { - setState(473); + setState(479); match(STRING); } } @@ -2782,11 +2824,11 @@ public class prog8Parser extends Parser { public final CharliteralContext charliteral() throws RecognitionException { CharliteralContext _localctx = new CharliteralContext(_ctx, getState()); - enterRule(_localctx, 78, RULE_charliteral); + enterRule(_localctx, 80, RULE_charliteral); try { enterOuterAlt(_localctx, 1); { - setState(475); + setState(481); match(SINGLECHAR); } } @@ -2811,11 +2853,11 @@ public class prog8Parser extends Parser { public final FloatliteralContext floatliteral() throws RecognitionException { FloatliteralContext _localctx = new FloatliteralContext(_ctx, getState()); - enterRule(_localctx, 80, RULE_floatliteral); + enterRule(_localctx, 82, RULE_floatliteral); try { enterOuterAlt(_localctx, 1); { - setState(477); + setState(483); match(FLOAT_NUMBER); } } @@ -2857,9 +2899,9 @@ public class prog8Parser extends Parser { public final LiteralvalueContext literalvalue() throws RecognitionException { LiteralvalueContext _localctx = new LiteralvalueContext(_ctx, getState()); - enterRule(_localctx, 82, RULE_literalvalue); + enterRule(_localctx, 84, RULE_literalvalue); try { - setState(485); + setState(491); _errHandler.sync(this); switch (_input.LA(1)) { case DEC_INTEGER: @@ -2867,7 +2909,7 @@ public class prog8Parser extends Parser { case BIN_INTEGER: enterOuterAlt(_localctx, 1); { - setState(479); + setState(485); integerliteral(); } break; @@ -2875,35 +2917,35 @@ public class prog8Parser extends Parser { case T__82: enterOuterAlt(_localctx, 2); { - setState(480); + setState(486); booleanliteral(); } break; case T__24: enterOuterAlt(_localctx, 3); { - setState(481); + setState(487); arrayliteral(); } break; case STRING: enterOuterAlt(_localctx, 4); { - setState(482); + setState(488); stringliteral(); } break; case SINGLECHAR: enterOuterAlt(_localctx, 5); { - setState(483); + setState(489); charliteral(); } break; case FLOAT_NUMBER: enterOuterAlt(_localctx, 6); { - setState(484); + setState(490); floatliteral(); } break; @@ -2932,13 +2974,13 @@ public class prog8Parser extends Parser { public final InlineasmContext inlineasm() throws RecognitionException { InlineasmContext _localctx = new InlineasmContext(_ctx, getState()); - enterRule(_localctx, 84, RULE_inlineasm); + enterRule(_localctx, 86, RULE_inlineasm); try { enterOuterAlt(_localctx, 1); { - setState(487); + setState(493); match(T__83); - setState(488); + setState(494); match(INLINEASMBLOCK); } } @@ -2975,43 +3017,43 @@ public class prog8Parser extends Parser { public final SubroutineContext subroutine() throws RecognitionException { SubroutineContext _localctx = new SubroutineContext(_ctx, getState()); - enterRule(_localctx, 86, RULE_subroutine); + enterRule(_localctx, 88, RULE_subroutine); int _la; try { enterOuterAlt(_localctx, 1); { - setState(490); + setState(496); match(T__84); - setState(491); + setState(497); identifier(); - setState(492); + setState(498); match(T__62); - setState(494); + setState(500); _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))) != 0)) { { - setState(493); + setState(499); sub_params(); } } - setState(496); + setState(502); match(T__63); - setState(498); + setState(504); _errHandler.sync(this); _la = _input.LA(1); if (_la==T__85) { { - setState(497); + setState(503); sub_return_part(); } } { - setState(500); + setState(506); statement_block(); - setState(501); + setState(507); match(EOL); } } @@ -3039,13 +3081,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, 88, RULE_sub_return_part); + enterRule(_localctx, 90, RULE_sub_return_part); try { enterOuterAlt(_localctx, 1); { - setState(503); + setState(509); match(T__85); - setState(504); + setState(510); sub_returns(); } } @@ -3079,21 +3121,21 @@ public class prog8Parser extends Parser { public final Statement_blockContext statement_block() throws RecognitionException { Statement_blockContext _localctx = new Statement_blockContext(_ctx, getState()); - enterRule(_localctx, 90, RULE_statement_block); + enterRule(_localctx, 92, RULE_statement_block); int _la; try { enterOuterAlt(_localctx, 1); { - setState(506); - match(T__86); - setState(507); - match(EOL); setState(512); + match(T__86); + setState(513); + match(EOL); + setState(518); _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))) != 0) || ((((_la - 66)) & ~0x3f) == 0 && ((1L << (_la - 66)) & ((1L << (T__65 - 66)) | (1L << (T__66 - 66)) | (1L << (T__67 - 66)) | (1L << (T__68 - 66)) | (1L << (T__70 - 66)) | (1L << (T__71 - 66)) | (1L << (T__72 - 66)) | (1L << (T__83 - 66)) | (1L << (T__84 - 66)) | (1L << (T__88 - 66)) | (1L << (T__91 - 66)) | (1L << (T__93 - 66)) | (1L << (T__94 - 66)) | (1L << (T__95 - 66)) | (1L << (T__96 - 66)) | (1L << (T__97 - 66)) | (1L << (T__98 - 66)) | (1L << (T__99 - 66)) | (1L << (T__100 - 66)) | (1L << (T__101 - 66)) | (1L << (T__102 - 66)) | (1L << (T__103 - 66)) | (1L << (T__104 - 66)) | (1L << (T__105 - 66)) | (1L << (T__107 - 66)) | (1L << (T__108 - 66)) | (1L << (EOL - 66)) | (1L << (NAME - 66)))) != 0)) { { - setState(510); + setState(516); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -3144,13 +3186,13 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(508); + setState(514); statement(); } break; case EOL: { - setState(509); + setState(515); match(EOL); } break; @@ -3158,11 +3200,11 @@ public class prog8Parser extends Parser { throw new NoViableAltException(this); } } - setState(514); + setState(520); _errHandler.sync(this); _la = _input.LA(1); } - setState(515); + setState(521); match(T__87); } } @@ -3196,36 +3238,36 @@ public class prog8Parser extends Parser { public final Sub_paramsContext sub_params() throws RecognitionException { Sub_paramsContext _localctx = new Sub_paramsContext(_ctx, getState()); - enterRule(_localctx, 92, RULE_sub_params); + enterRule(_localctx, 94, RULE_sub_params); int _la; try { enterOuterAlt(_localctx, 1); { - setState(517); + setState(523); vardecl(); - setState(525); + setState(531); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(518); + setState(524); match(T__13); - setState(520); + setState(526); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(519); + setState(525); match(EOL); } } - setState(522); + setState(528); vardecl(); } } - setState(527); + setState(533); _errHandler.sync(this); _la = _input.LA(1); } @@ -3261,36 +3303,36 @@ public class prog8Parser extends Parser { public final Sub_returnsContext sub_returns() throws RecognitionException { Sub_returnsContext _localctx = new Sub_returnsContext(_ctx, getState()); - enterRule(_localctx, 94, RULE_sub_returns); + enterRule(_localctx, 96, RULE_sub_returns); int _la; try { enterOuterAlt(_localctx, 1); { - setState(528); + setState(534); datatype(); - setState(536); + setState(542); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(529); + setState(535); match(T__13); - setState(531); + setState(537); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(530); + setState(536); match(EOL); } } - setState(533); + setState(539); datatype(); } } - setState(538); + setState(544); _errHandler.sync(this); _la = _input.LA(1); } @@ -3334,75 +3376,75 @@ public class prog8Parser extends Parser { public final AsmsubroutineContext asmsubroutine() throws RecognitionException { AsmsubroutineContext _localctx = new AsmsubroutineContext(_ctx, getState()); - enterRule(_localctx, 96, RULE_asmsubroutine); + enterRule(_localctx, 98, RULE_asmsubroutine); int _la; try { enterOuterAlt(_localctx, 1); { - setState(539); + setState(545); match(T__88); - setState(540); + setState(546); identifier(); - setState(541); + setState(547); match(T__62); - setState(543); + setState(549); _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))) != 0)) { { - setState(542); + setState(548); asmsub_params(); } } - setState(545); + setState(551); match(T__63); - setState(546); - match(T__85); - setState(547); - match(T__89); - setState(548); - match(T__62); - setState(550); - _errHandler.sync(this); - _la = _input.LA(1); - if (((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) { - { - setState(549); - clobber(); - } - } - setState(552); - match(T__63); - setState(553); match(T__85); + setState(553); + match(T__89); setState(554); match(T__62); setState(556); _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))) != 0)) { + if (((((_la - 71)) & ~0x3f) == 0 && ((1L << (_la - 71)) & ((1L << (T__70 - 71)) | (1L << (T__71 - 71)) | (1L << (T__72 - 71)))) != 0)) { { setState(555); - asmsub_returns(); + clobber(); } } setState(558); match(T__63); - setState(561); + setState(559); + match(T__85); + setState(560); + match(T__62); + setState(562); + _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))) != 0)) { + { + setState(561); + asmsub_returns(); + } + } + + setState(564); + match(T__63); + setState(567); _errHandler.sync(this); switch (_input.LA(1)) { case T__14: { - setState(559); + setState(565); asmsub_address(); } break; case T__86: { - setState(560); + setState(566); statement_block(); } break; @@ -3435,13 +3477,13 @@ public class prog8Parser extends Parser { public final Asmsub_addressContext asmsub_address() throws RecognitionException { Asmsub_addressContext _localctx = new Asmsub_addressContext(_ctx, getState()); - enterRule(_localctx, 98, RULE_asmsub_address); + enterRule(_localctx, 100, RULE_asmsub_address); try { enterOuterAlt(_localctx, 1); { - setState(563); + setState(569); match(T__14); - setState(564); + setState(570); ((Asmsub_addressContext)_localctx).address = integerliteral(); } } @@ -3475,36 +3517,36 @@ public class prog8Parser extends Parser { public final Asmsub_paramsContext asmsub_params() throws RecognitionException { Asmsub_paramsContext _localctx = new Asmsub_paramsContext(_ctx, getState()); - enterRule(_localctx, 100, RULE_asmsub_params); + enterRule(_localctx, 102, RULE_asmsub_params); int _la; try { enterOuterAlt(_localctx, 1); { - setState(566); + setState(572); asmsub_param(); - setState(574); + setState(580); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(567); + setState(573); match(T__13); - setState(569); + setState(575); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(568); + setState(574); match(EOL); } } - setState(571); + setState(577); asmsub_param(); } } - setState(576); + setState(582); _errHandler.sync(this); _la = _input.LA(1); } @@ -3540,15 +3582,15 @@ public class prog8Parser extends Parser { public final Asmsub_paramContext asmsub_param() throws RecognitionException { Asmsub_paramContext _localctx = new Asmsub_paramContext(_ctx, getState()); - enterRule(_localctx, 102, RULE_asmsub_param); + enterRule(_localctx, 104, RULE_asmsub_param); try { enterOuterAlt(_localctx, 1); { - setState(577); + setState(583); vardecl(); - setState(578); + setState(584); match(T__65); - setState(582); + setState(588); _errHandler.sync(this); switch (_input.LA(1)) { case T__70: @@ -3558,7 +3600,7 @@ public class prog8Parser extends Parser { case T__74: case T__75: { - setState(579); + setState(585); registerorpair(); } break; @@ -3567,13 +3609,13 @@ public class prog8Parser extends Parser { case T__78: case T__79: { - setState(580); + setState(586); statusregister(); } break; case T__90: { - setState(581); + setState(587); ((Asmsub_paramContext)_localctx).stack = match(T__90); } break; @@ -3608,26 +3650,26 @@ public class prog8Parser extends Parser { public final ClobberContext clobber() throws RecognitionException { ClobberContext _localctx = new ClobberContext(_ctx, getState()); - enterRule(_localctx, 104, RULE_clobber); + enterRule(_localctx, 106, RULE_clobber); int _la; try { enterOuterAlt(_localctx, 1); { - setState(584); + setState(590); register(); - setState(589); + setState(595); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(585); + setState(591); match(T__13); - setState(586); + setState(592); register(); } } - setState(591); + setState(597); _errHandler.sync(this); _la = _input.LA(1); } @@ -3663,36 +3705,36 @@ public class prog8Parser extends Parser { public final Asmsub_returnsContext asmsub_returns() throws RecognitionException { Asmsub_returnsContext _localctx = new Asmsub_returnsContext(_ctx, getState()); - enterRule(_localctx, 106, RULE_asmsub_returns); + enterRule(_localctx, 108, RULE_asmsub_returns); int _la; try { enterOuterAlt(_localctx, 1); { - setState(592); + setState(598); asmsub_return(); - setState(600); + setState(606); _errHandler.sync(this); _la = _input.LA(1); while (_la==T__13) { { { - setState(593); + setState(599); match(T__13); - setState(595); + setState(601); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(594); + setState(600); match(EOL); } } - setState(597); + setState(603); asmsub_return(); } } - setState(602); + setState(608); _errHandler.sync(this); _la = _input.LA(1); } @@ -3728,15 +3770,15 @@ public class prog8Parser extends Parser { public final Asmsub_returnContext asmsub_return() throws RecognitionException { Asmsub_returnContext _localctx = new Asmsub_returnContext(_ctx, getState()); - enterRule(_localctx, 108, RULE_asmsub_return); + enterRule(_localctx, 110, RULE_asmsub_return); try { enterOuterAlt(_localctx, 1); { - setState(603); + setState(609); datatype(); - setState(604); + setState(610); match(T__65); - setState(608); + setState(614); _errHandler.sync(this); switch (_input.LA(1)) { case T__70: @@ -3746,7 +3788,7 @@ public class prog8Parser extends Parser { case T__74: case T__75: { - setState(605); + setState(611); registerorpair(); } break; @@ -3755,13 +3797,13 @@ public class prog8Parser extends Parser { case T__78: case T__79: { - setState(606); + setState(612); statusregister(); } break; case T__90: { - setState(607); + setState(613); ((Asmsub_returnContext)_localctx).stack = match(T__90); } break; @@ -3806,26 +3848,26 @@ public class prog8Parser extends Parser { public final If_stmtContext if_stmt() throws RecognitionException { If_stmtContext _localctx = new If_stmtContext(_ctx, getState()); - enterRule(_localctx, 110, RULE_if_stmt); + enterRule(_localctx, 112, RULE_if_stmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(610); + setState(616); match(T__91); - setState(611); + setState(617); expression(0); - setState(613); + setState(619); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(612); + setState(618); match(EOL); } } - setState(617); + setState(623); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -3876,35 +3918,35 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(615); + setState(621); statement(); } break; case T__86: { - setState(616); + setState(622); statement_block(); } break; default: throw new NoViableAltException(this); } - setState(620); + setState(626); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,75,_ctx) ) { case 1: { - setState(619); + setState(625); match(EOL); } break; } - setState(623); + setState(629); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,76,_ctx) ) { case 1: { - setState(622); + setState(628); else_part(); } break; @@ -3938,24 +3980,24 @@ public class prog8Parser extends Parser { public final Else_partContext else_part() throws RecognitionException { Else_partContext _localctx = new Else_partContext(_ctx, getState()); - enterRule(_localctx, 112, RULE_else_part); + enterRule(_localctx, 114, RULE_else_part); int _la; try { enterOuterAlt(_localctx, 1); { - setState(625); + setState(631); match(T__92); - setState(627); + setState(633); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(626); + setState(632); match(EOL); } } - setState(631); + setState(637); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -4006,13 +4048,13 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(629); + setState(635); statement(); } break; case T__86: { - setState(630); + setState(636); statement_block(); } break; @@ -4057,24 +4099,24 @@ public class prog8Parser extends Parser { public final Branch_stmtContext branch_stmt() throws RecognitionException { Branch_stmtContext _localctx = new Branch_stmtContext(_ctx, getState()); - enterRule(_localctx, 114, RULE_branch_stmt); + enterRule(_localctx, 116, RULE_branch_stmt); int _la; try { enterOuterAlt(_localctx, 1); { - setState(633); + setState(639); branchcondition(); - setState(635); + setState(641); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(634); + setState(640); match(EOL); } } - setState(639); + setState(645); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -4125,40 +4167,40 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(637); + setState(643); statement(); } break; case T__86: { - setState(638); + setState(644); statement_block(); } break; default: throw new NoViableAltException(this); } - setState(642); + setState(648); _errHandler.sync(this); switch ( getInterpreter().adaptivePredict(_input,81,_ctx) ) { case 1: { - setState(641); + setState(647); match(EOL); } break; } - setState(645); + setState(651); _errHandler.sync(this); _la = _input.LA(1); if (_la==T__92) { { - setState(644); + setState(650); else_part(); } } - setState(647); + setState(653); match(EOL); } } @@ -4182,12 +4224,12 @@ public class prog8Parser extends Parser { public final BranchconditionContext branchcondition() throws RecognitionException { BranchconditionContext _localctx = new BranchconditionContext(_ctx, getState()); - enterRule(_localctx, 116, RULE_branchcondition); + enterRule(_localctx, 118, RULE_branchcondition); int _la; try { enterOuterAlt(_localctx, 1); { - setState(649); + setState(655); _la = _input.LA(1); if ( !(((((_la - 94)) & ~0x3f) == 0 && ((1L << (_la - 94)) & ((1L << (T__93 - 94)) | (1L << (T__94 - 94)) | (1L << (T__95 - 94)) | (1L << (T__96 - 94)) | (1L << (T__97 - 94)) | (1L << (T__98 - 94)) | (1L << (T__99 - 94)) | (1L << (T__100 - 94)) | (1L << (T__101 - 94)) | (1L << (T__102 - 94)) | (1L << (T__103 - 94)) | (1L << (T__104 - 94)))) != 0)) ) { _errHandler.recoverInline(this); @@ -4239,68 +4281,68 @@ public class prog8Parser extends Parser { public final ForloopContext forloop() throws RecognitionException { ForloopContext _localctx = new ForloopContext(_ctx, getState()); - enterRule(_localctx, 118, RULE_forloop); + enterRule(_localctx, 120, RULE_forloop); int _la; try { enterOuterAlt(_localctx, 1); { - setState(651); + setState(657); match(T__105); - setState(653); + setState(659); _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))) != 0)) { { - setState(652); + setState(658); datatype(); } } - setState(656); + setState(662); _errHandler.sync(this); _la = _input.LA(1); if (_la==ZEROPAGE) { { - setState(655); + setState(661); match(ZEROPAGE); } } - setState(660); + setState(666); _errHandler.sync(this); switch (_input.LA(1)) { case T__70: case T__71: case T__72: { - setState(658); + setState(664); register(); } break; case NAME: { - setState(659); + setState(665); identifier(); } break; default: throw new NoViableAltException(this); } - setState(662); + setState(668); match(T__106); - setState(663); + setState(669); expression(0); - setState(665); + setState(671); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(664); + setState(670); match(EOL); } } - setState(669); + setState(675); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -4351,13 +4393,13 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(667); + setState(673); statement(); } break; case T__86: { - setState(668); + setState(674); statement_block(); } break; @@ -4396,26 +4438,26 @@ public class prog8Parser extends Parser { public final WhileloopContext whileloop() throws RecognitionException { WhileloopContext _localctx = new WhileloopContext(_ctx, getState()); - enterRule(_localctx, 120, RULE_whileloop); + enterRule(_localctx, 122, RULE_whileloop); int _la; try { enterOuterAlt(_localctx, 1); { - setState(671); + setState(677); match(T__107); - setState(672); + setState(678); expression(0); - setState(674); + setState(680); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(673); + setState(679); match(EOL); } } - setState(678); + setState(684); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -4466,13 +4508,13 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(676); + setState(682); statement(); } break; case T__86: { - setState(677); + setState(683); statement_block(); } break; @@ -4511,14 +4553,14 @@ public class prog8Parser extends Parser { public final RepeatloopContext repeatloop() throws RecognitionException { RepeatloopContext _localctx = new RepeatloopContext(_ctx, getState()); - enterRule(_localctx, 122, RULE_repeatloop); + enterRule(_localctx, 124, RULE_repeatloop); int _la; try { enterOuterAlt(_localctx, 1); { - setState(680); + setState(686); match(T__108); - setState(683); + setState(689); _errHandler.sync(this); switch (_input.LA(1)) { case T__2: @@ -4569,32 +4611,32 @@ public class prog8Parser extends Parser { case T__108: case NAME: { - setState(681); + setState(687); statement(); } break; case T__86: { - setState(682); + setState(688); statement_block(); } break; default: throw new NoViableAltException(this); } - setState(686); + setState(692); _errHandler.sync(this); _la = _input.LA(1); if (_la==EOL) { { - setState(685); + setState(691); match(EOL); } } - setState(688); + setState(694); match(T__109); - setState(689); + setState(695); expression(0); } } @@ -4619,31 +4661,31 @@ public class prog8Parser extends Parser { private boolean expression_sempred(ExpressionContext _localctx, int predIndex) { switch (predIndex) { case 0: - return precpred(_ctx, 21); + return precpred(_ctx, 22); case 1: - return precpred(_ctx, 20); + return precpred(_ctx, 21); case 2: - return precpred(_ctx, 19); + return precpred(_ctx, 20); case 3: - return precpred(_ctx, 18); + return precpred(_ctx, 19); case 4: - return precpred(_ctx, 17); + return precpred(_ctx, 18); case 5: - return precpred(_ctx, 16); + return precpred(_ctx, 17); case 6: - return precpred(_ctx, 15); + return precpred(_ctx, 16); case 7: - return precpred(_ctx, 14); + return precpred(_ctx, 15); case 8: - return precpred(_ctx, 13); + return precpred(_ctx, 14); case 9: - return precpred(_ctx, 11); - case 10: - return precpred(_ctx, 10); - case 11: - return precpred(_ctx, 9); - case 12: return precpred(_ctx, 12); + case 10: + return precpred(_ctx, 11); + case 11: + return precpred(_ctx, 10); + case 12: + return precpred(_ctx, 13); case 13: return precpred(_ctx, 2); } @@ -4651,7 +4693,7 @@ public class prog8Parser extends Parser { } public static final String _serializedATN = - "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3}\u02b6\4\2\t\2\4"+ + "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\3}\u02bc\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"+ @@ -4659,270 +4701,272 @@ 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="+ - "\4>\t>\4?\t?\3\2\3\2\7\2\u0081\n\2\f\2\16\2\u0084\13\2\3\2\3\2\3\3\3\3"+ - "\5\3\u008a\n\3\3\4\3\4\3\4\5\4\u008f\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\u00aa\n\5\3\6\3\6\3\6\3\7\3\7\3\7\5\7\u00b2\n\7\3\b\3\b\5\b\u00b6"+ - "\n\b\3\b\3\b\3\b\7\b\u00bb\n\b\f\b\16\b\u00be\13\b\5\b\u00c0\n\b\3\t\3"+ - "\t\3\t\5\t\u00c5\n\t\3\n\3\n\5\n\u00c9\n\n\3\n\5\n\u00cc\n\n\3\n\3\n\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\5\25\u010c\n\25\3\25\3\25\5\25"+ - "\u0110\n\25\3\25\3\25\3\25\5\25\u0115\n\25\3\25\3\25\5\25\u0119\n\25\3"+ - "\25\3\25\3\25\5\25\u011e\n\25\3\25\3\25\5\25\u0122\n\25\3\25\3\25\3\25"+ - "\5\25\u0127\n\25\3\25\3\25\5\25\u012b\n\25\3\25\3\25\3\25\5\25\u0130\n"+ - "\25\3\25\3\25\5\25\u0134\n\25\3\25\3\25\3\25\5\25\u0139\n\25\3\25\3\25"+ - "\5\25\u013d\n\25\3\25\3\25\3\25\5\25\u0142\n\25\3\25\3\25\5\25\u0146\n"+ - "\25\3\25\3\25\3\25\5\25\u014b\n\25\3\25\3\25\5\25\u014f\n\25\3\25\3\25"+ - "\3\25\5\25\u0154\n\25\3\25\3\25\5\25\u0158\n\25\3\25\3\25\3\25\5\25\u015d"+ - "\n\25\3\25\3\25\5\25\u0161\n\25\3\25\3\25\3\25\5\25\u0166\n\25\3\25\3"+ - "\25\5\25\u016a\n\25\3\25\3\25\3\25\5\25\u016f\n\25\3\25\3\25\5\25\u0173"+ - "\n\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u017b\n\25\3\25\3\25\7\25\u017f"+ - "\n\25\f\25\16\25\u0182\13\25\3\26\3\26\3\26\3\27\3\27\3\27\3\30\3\30\3"+ - "\30\3\30\3\30\3\31\3\31\3\31\5\31\u0192\n\31\3\31\3\31\3\32\3\32\3\32"+ - "\5\32\u0199\n\32\3\32\3\32\3\33\3\33\3\33\5\33\u01a0\n\33\3\33\7\33\u01a3"+ - "\n\33\f\33\16\33\u01a6\13\33\3\34\3\34\5\34\u01aa\n\34\3\35\3\35\3\36"+ - "\3\36\3\37\3\37\3 \3 \3 \7 \u01b5\n \f \16 \u01b8\13 \3!\3!\3\"\3\"\3"+ - "#\3#\3$\3$\5$\u01c2\n$\3%\3%\3&\3&\3\'\3\'\5\'\u01ca\n\'\3\'\3\'\3\'\5"+ - "\'\u01cf\n\'\3\'\7\'\u01d2\n\'\f\'\16\'\u01d5\13\'\3\'\5\'\u01d8\n\'\3"+ - "\'\3\'\3(\3(\3)\3)\3*\3*\3+\3+\3+\3+\3+\3+\5+\u01e8\n+\3,\3,\3,\3-\3-"+ - "\3-\3-\5-\u01f1\n-\3-\3-\5-\u01f5\n-\3-\3-\3-\3.\3.\3.\3/\3/\3/\3/\7/"+ - "\u0201\n/\f/\16/\u0204\13/\3/\3/\3\60\3\60\3\60\5\60\u020b\n\60\3\60\7"+ - "\60\u020e\n\60\f\60\16\60\u0211\13\60\3\61\3\61\3\61\5\61\u0216\n\61\3"+ - "\61\7\61\u0219\n\61\f\61\16\61\u021c\13\61\3\62\3\62\3\62\3\62\5\62\u0222"+ - "\n\62\3\62\3\62\3\62\3\62\3\62\5\62\u0229\n\62\3\62\3\62\3\62\3\62\5\62"+ - "\u022f\n\62\3\62\3\62\3\62\5\62\u0234\n\62\3\63\3\63\3\63\3\64\3\64\3"+ - "\64\5\64\u023c\n\64\3\64\7\64\u023f\n\64\f\64\16\64\u0242\13\64\3\65\3"+ - "\65\3\65\3\65\3\65\5\65\u0249\n\65\3\66\3\66\3\66\7\66\u024e\n\66\f\66"+ - "\16\66\u0251\13\66\3\67\3\67\3\67\5\67\u0256\n\67\3\67\7\67\u0259\n\67"+ - "\f\67\16\67\u025c\13\67\38\38\38\38\38\58\u0263\n8\39\39\39\59\u0268\n"+ - "9\39\39\59\u026c\n9\39\59\u026f\n9\39\59\u0272\n9\3:\3:\5:\u0276\n:\3"+ - ":\3:\5:\u027a\n:\3;\3;\5;\u027e\n;\3;\3;\5;\u0282\n;\3;\5;\u0285\n;\3"+ - ";\5;\u0288\n;\3;\3;\3<\3<\3=\3=\5=\u0290\n=\3=\5=\u0293\n=\3=\3=\5=\u0297"+ - "\n=\3=\3=\3=\5=\u029c\n=\3=\3=\5=\u02a0\n=\3>\3>\3>\5>\u02a5\n>\3>\3>"+ - "\5>\u02a9\n>\3?\3?\3?\5?\u02ae\n?\3?\5?\u02b1\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:<>@BDFHJLNP"+ - "RTVXZ\\^`bdfhjlnprtvxz|\2\22\3\2\6\17\3\2\24\32\3\2\35\'\3\2()\4\2\3\3"+ - "*+\3\2-/\3\2*+\3\2\60\61\3\2\62\65\3\2\66\67\3\2IK\3\2IN\3\2OR\3\2vx\3"+ - "\2TU\3\2`k\2\u0303\2\u0082\3\2\2\2\4\u0089\3\2\2\2\6\u008b\3\2\2\2\b\u00a9"+ - "\3\2\2\2\n\u00ab\3\2\2\2\f\u00ae\3\2\2\2\16\u00b3\3\2\2\2\20\u00c4\3\2"+ - "\2\2\22\u00c6\3\2\2\2\24\u00cf\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*\u0183\3\2"+ - "\2\2,\u0186\3\2\2\2.\u0189\3\2\2\2\60\u018e\3\2\2\2\62\u0195\3\2\2\2\64"+ - "\u019c\3\2\2\2\66\u01a7\3\2\2\28\u01ab\3\2\2\2:\u01ad\3\2\2\2<\u01af\3"+ - "\2\2\2>\u01b1\3\2\2\2@\u01b9\3\2\2\2B\u01bb\3\2\2\2D\u01bd\3\2\2\2F\u01bf"+ - "\3\2\2\2H\u01c3\3\2\2\2J\u01c5\3\2\2\2L\u01c7\3\2\2\2N\u01db\3\2\2\2P"+ - "\u01dd\3\2\2\2R\u01df\3\2\2\2T\u01e7\3\2\2\2V\u01e9\3\2\2\2X\u01ec\3\2"+ - "\2\2Z\u01f9\3\2\2\2\\\u01fc\3\2\2\2^\u0207\3\2\2\2`\u0212\3\2\2\2b\u021d"+ - "\3\2\2\2d\u0235\3\2\2\2f\u0238\3\2\2\2h\u0243\3\2\2\2j\u024a\3\2\2\2l"+ - "\u0252\3\2\2\2n\u025d\3\2\2\2p\u0264\3\2\2\2r\u0273\3\2\2\2t\u027b\3\2"+ - "\2\2v\u028b\3\2\2\2x\u028d\3\2\2\2z\u02a1\3\2\2\2|\u02aa\3\2\2\2~\u0081"+ - "\5\4\3\2\177\u0081\7t\2\2\u0080~\3\2\2\2\u0080\177\3\2\2\2\u0081\u0084"+ - "\3\2\2\2\u0082\u0080\3\2\2\2\u0082\u0083\3\2\2\2\u0083\u0085\3\2\2\2\u0084"+ - "\u0082\3\2\2\2\u0085\u0086\7\2\2\3\u0086\3\3\2\2\2\u0087\u008a\5\16\b"+ - "\2\u0088\u008a\5\6\4\2\u0089\u0087\3\2\2\2\u0089\u0088\3\2\2\2\u008a\5"+ - "\3\2\2\2\u008b\u008c\7\3\2\2\u008c\u008e\5<\37\2\u008d\u008f\5F$\2\u008e"+ - "\u008d\3\2\2\2\u008e\u008f\3\2\2\2\u008f\u0090\3\2\2\2\u0090\u0091\5\\"+ - "/\2\u0091\u0092\7t\2\2\u0092\7\3\2\2\2\u0093\u00aa\5\16\b\2\u0094\u00aa"+ - "\5\24\13\2\u0095\u00aa\5\22\n\2\u0096\u00aa\5\26\f\2\u0097\u00aa\5\30"+ - "\r\2\u0098\u00aa\5\36\20\2\u0099\u00aa\5\"\22\2\u009a\u00aa\5\f\7\2\u009b"+ - "\u00aa\5&\24\2\u009c\u00aa\5\62\32\2\u009d\u00aa\5p9\2\u009e\u00aa\5t"+ - ";\2\u009f\u00aa\5X-\2\u00a0\u00aa\5b\62\2\u00a1\u00aa\5V,\2\u00a2\u00aa"+ - "\5\66\34\2\u00a3\u00aa\5x=\2\u00a4\u00aa\5z>\2\u00a5\u00aa\5|?\2\u00a6"+ - "\u00aa\58\35\2\u00a7\u00aa\5:\36\2\u00a8\u00aa\5\n\6\2\u00a9\u0093\3\2"+ - "\2\2\u00a9\u0094\3\2\2\2\u00a9\u0095\3\2\2\2\u00a9\u0096\3\2\2\2\u00a9"+ - "\u0097\3\2\2\2\u00a9\u0098\3\2\2\2\u00a9\u0099\3\2\2\2\u00a9\u009a\3\2"+ - "\2\2\u00a9\u009b\3\2\2\2\u00a9\u009c\3\2\2\2\u00a9\u009d\3\2\2\2\u00a9"+ - "\u009e\3\2\2\2\u00a9\u009f\3\2\2\2\u00a9\u00a0\3\2\2\2\u00a9\u00a1\3\2"+ - "\2\2\u00a9\u00a2\3\2\2\2\u00a9\u00a3\3\2\2\2\u00a9\u00a4\3\2\2\2\u00a9"+ - "\u00a5\3\2\2\2\u00a9\u00a6\3\2\2\2\u00a9\u00a7\3\2\2\2\u00a9\u00a8\3\2"+ - "\2\2\u00aa\t\3\2\2\2\u00ab\u00ac\5<\37\2\u00ac\u00ad\7\4\2\2\u00ad\13"+ - "\3\2\2\2\u00ae\u00b1\7\5\2\2\u00af\u00b2\5F$\2\u00b0\u00b2\5> \2\u00b1"+ - "\u00af\3\2\2\2\u00b1\u00b0\3\2\2\2\u00b2\r\3\2\2\2\u00b3\u00bf\t\2\2\2"+ - "\u00b4\u00b6\5\20\t\2\u00b5\u00b4\3\2\2\2\u00b5\u00b6\3\2\2\2\u00b6\u00c0"+ - "\3\2\2\2\u00b7\u00bc\5\20\t\2\u00b8\u00b9\7\20\2\2\u00b9\u00bb\5\20\t"+ - "\2\u00ba\u00b8\3\2\2\2\u00bb\u00be\3\2\2\2\u00bc\u00ba\3\2\2\2\u00bc\u00bd"+ - "\3\2\2\2\u00bd\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00bf\u00b5\3\2\2\2\u00bf"+ - "\u00b7\3\2\2\2\u00c0\17\3\2\2\2\u00c1\u00c5\5N(\2\u00c2\u00c5\5<\37\2"+ - "\u00c3\u00c5\5F$\2\u00c4\u00c1\3\2\2\2\u00c4\u00c2\3\2\2\2\u00c4\u00c3"+ - "\3\2\2\2\u00c5\21\3\2\2\2\u00c6\u00c8\5\32\16\2\u00c7\u00c9\7}\2\2\u00c8"+ - "\u00c7\3\2\2\2\u00c8\u00c9\3\2\2\2\u00c9\u00cb\3\2\2\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<\37\2\u00ce\23\3\2\2\2\u00cf\u00d0\5\22\n\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\33"+ - "\2\2\u00dc\u00dd\5(\25\2\u00dd\u00de\7\34\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@!\2\u00f0\u00f4\5> "+ - "\2\u00f1\u00f4\5,\27\2\u00f2\u00f4\5.\30\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\u0108\5\60\31\2\u00fa\u00fb\t\6\2\2\u00fb\u0108\5(\25\30\u00fc"+ - "\u00fd\7@\2\2\u00fd\u0108\5(\25\n\u00fe\u0108\5T+\2\u00ff\u0108\5@!\2"+ - "\u0100\u0108\5> \2\u0101\u0108\5,\27\2\u0102\u0108\5.\30\2\u0103\u0104"+ - "\7A\2\2\u0104\u0105\5(\25\2\u0105\u0106\7B\2\2\u0106\u0108\3\2\2\2\u0107"+ - "\u00f8\3\2\2\2\u0107\u00fa\3\2\2\2\u0107\u00fc\3\2\2\2\u0107\u00fe\3\2"+ - "\2\2\u0107\u00ff\3\2\2\2\u0107\u0100\3\2\2\2\u0107\u0101\3\2\2\2\u0107"+ - "\u0102\3\2\2\2\u0107\u0103\3\2\2\2\u0108\u0180\3\2\2\2\u0109\u010b\f\27"+ - "\2\2\u010a\u010c\7t\2\2\u010b\u010a\3\2\2\2\u010b\u010c\3\2\2\2\u010c"+ - "\u010d\3\2\2\2\u010d\u010f\7,\2\2\u010e\u0110\7t\2\2\u010f\u010e\3\2\2"+ - "\2\u010f\u0110\3\2\2\2\u0110\u0111\3\2\2\2\u0111\u017f\5(\25\30\u0112"+ - "\u0114\f\26\2\2\u0113\u0115\7t\2\2\u0114\u0113\3\2\2\2\u0114\u0115\3\2"+ - "\2\2\u0115\u0116\3\2\2\2\u0116\u0118\t\7\2\2\u0117\u0119\7t\2\2\u0118"+ - "\u0117\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011a\3\2\2\2\u011a\u017f\5("+ - "\25\27\u011b\u011d\f\25\2\2\u011c\u011e\7t\2\2\u011d\u011c\3\2\2\2\u011d"+ - "\u011e\3\2\2\2\u011e\u011f\3\2\2\2\u011f\u0121\t\b\2\2\u0120\u0122\7t"+ - "\2\2\u0121\u0120\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0123\3\2\2\2\u0123"+ - "\u017f\5(\25\26\u0124\u0126\f\24\2\2\u0125\u0127\7t\2\2\u0126\u0125\3"+ - "\2\2\2\u0126\u0127\3\2\2\2\u0127\u0128\3\2\2\2\u0128\u012a\t\t\2\2\u0129"+ - "\u012b\7t\2\2\u012a\u0129\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012c\3\2"+ - "\2\2\u012c\u017f\5(\25\25\u012d\u012f\f\23\2\2\u012e\u0130\7t\2\2\u012f"+ - "\u012e\3\2\2\2\u012f\u0130\3\2\2\2\u0130\u0131\3\2\2\2\u0131\u0133\t\n"+ - "\2\2\u0132\u0134\7t\2\2\u0133\u0132\3\2\2\2\u0133\u0134\3\2\2\2\u0134"+ - "\u0135\3\2\2\2\u0135\u017f\5(\25\24\u0136\u0138\f\22\2\2\u0137\u0139\7"+ - "t\2\2\u0138\u0137\3\2\2\2\u0138\u0139\3\2\2\2\u0139\u013a\3\2\2\2\u013a"+ - "\u013c\t\13\2\2\u013b\u013d\7t\2\2\u013c\u013b\3\2\2\2\u013c\u013d\3\2"+ - "\2\2\u013d\u013e\3\2\2\2\u013e\u017f\5(\25\23\u013f\u0141\f\21\2\2\u0140"+ - "\u0142\7t\2\2\u0141\u0140\3\2\2\2\u0141\u0142\3\2\2\2\u0142\u0143\3\2"+ - "\2\2\u0143\u0145\78\2\2\u0144\u0146\7t\2\2\u0145\u0144\3\2\2\2\u0145\u0146"+ - "\3\2\2\2\u0146\u0147\3\2\2\2\u0147\u017f\5(\25\22\u0148\u014a\f\20\2\2"+ - "\u0149\u014b\7t\2\2\u014a\u0149\3\2\2\2\u014a\u014b\3\2\2\2\u014b\u014c"+ - "\3\2\2\2\u014c\u014e\79\2\2\u014d\u014f\7t\2\2\u014e\u014d\3\2\2\2\u014e"+ - "\u014f\3\2\2\2\u014f\u0150\3\2\2\2\u0150\u017f\5(\25\21\u0151\u0153\f"+ - "\17\2\2\u0152\u0154\7t\2\2\u0153\u0152\3\2\2\2\u0153\u0154\3\2\2\2\u0154"+ - "\u0155\3\2\2\2\u0155\u0157\7:\2\2\u0156\u0158\7t\2\2\u0157\u0156\3\2\2"+ - "\2\u0157\u0158\3\2\2\2\u0158\u0159\3\2\2\2\u0159\u017f\5(\25\20\u015a"+ - "\u015c\f\r\2\2\u015b\u015d\7t\2\2\u015c\u015b\3\2\2\2\u015c\u015d\3\2"+ - "\2\2\u015d\u015e\3\2\2\2\u015e\u0160\7=\2\2\u015f\u0161\7t\2\2\u0160\u015f"+ - "\3\2\2\2\u0160\u0161\3\2\2\2\u0161\u0162\3\2\2\2\u0162\u017f\5(\25\16"+ - "\u0163\u0165\f\f\2\2\u0164\u0166\7t\2\2\u0165\u0164\3\2\2\2\u0165\u0166"+ - "\3\2\2\2\u0166\u0167\3\2\2\2\u0167\u0169\7>\2\2\u0168\u016a\7t\2\2\u0169"+ - "\u0168\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016b\3\2\2\2\u016b\u017f\5("+ - "\25\r\u016c\u016e\f\13\2\2\u016d\u016f\7t\2\2\u016e\u016d\3\2\2\2\u016e"+ - "\u016f\3\2\2\2\u016f\u0170\3\2\2\2\u0170\u0172\7?\2\2\u0171\u0173\7t\2"+ - "\2\u0172\u0171\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0174\3\2\2\2\u0174\u017f"+ - "\5(\25\f\u0175\u0176\f\16\2\2\u0176\u0177\7;\2\2\u0177\u017a\5(\25\2\u0178"+ - "\u0179\7<\2\2\u0179\u017b\5(\25\2\u017a\u0178\3\2\2\2\u017a\u017b\3\2"+ - "\2\2\u017b\u017f\3\2\2\2\u017c\u017d\f\4\2\2\u017d\u017f\5*\26\2\u017e"+ - "\u0109\3\2\2\2\u017e\u0112\3\2\2\2\u017e\u011b\3\2\2\2\u017e\u0124\3\2"+ - "\2\2\u017e\u012d\3\2\2\2\u017e\u0136\3\2\2\2\u017e\u013f\3\2\2\2\u017e"+ - "\u0148\3\2\2\2\u017e\u0151\3\2\2\2\u017e\u015a\3\2\2\2\u017e\u0163\3\2"+ - "\2\2\u017e\u016c\3\2\2\2\u017e\u0175\3\2\2\2\u017e\u017c\3\2\2\2\u017f"+ - "\u0182\3\2\2\2\u0180\u017e\3\2\2\2\u0180\u0181\3\2\2\2\u0181)\3\2\2\2"+ - "\u0182\u0180\3\2\2\2\u0183\u0184\7C\2\2\u0184\u0185\5\32\16\2\u0185+\3"+ - "\2\2\2\u0186\u0187\5> \2\u0187\u0188\5\34\17\2\u0188-\3\2\2\2\u0189\u018a"+ - "\7D\2\2\u018a\u018b\7A\2\2\u018b\u018c\5(\25\2\u018c\u018d\7B\2\2\u018d"+ - "/\3\2\2\2\u018e\u018f\5> \2\u018f\u0191\7A\2\2\u0190\u0192\5\64\33\2\u0191"+ - "\u0190\3\2\2\2\u0191\u0192\3\2\2\2\u0192\u0193\3\2\2\2\u0193\u0194\7B"+ - "\2\2\u0194\61\3\2\2\2\u0195\u0196\5> \2\u0196\u0198\7A\2\2\u0197\u0199"+ - "\5\64\33\2\u0198\u0197\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a\3\2\2\2"+ - "\u019a\u019b\7B\2\2\u019b\63\3\2\2\2\u019c\u01a4\5(\25\2\u019d\u019f\7"+ - "\20\2\2\u019e\u01a0\7t\2\2\u019f\u019e\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0"+ - "\u01a1\3\2\2\2\u01a1\u01a3\5(\25\2\u01a2\u019d\3\2\2\2\u01a3\u01a6\3\2"+ - "\2\2\u01a4\u01a2\3\2\2\2\u01a4\u01a5\3\2\2\2\u01a5\65\3\2\2\2\u01a6\u01a4"+ - "\3\2\2\2\u01a7\u01a9\7E\2\2\u01a8\u01aa\5\64\33\2\u01a9\u01a8\3\2\2\2"+ - "\u01a9\u01aa\3\2\2\2\u01aa\67\3\2\2\2\u01ab\u01ac\7F\2\2\u01ac9\3\2\2"+ - "\2\u01ad\u01ae\7G\2\2\u01ae;\3\2\2\2\u01af\u01b0\7u\2\2\u01b0=\3\2\2\2"+ - "\u01b1\u01b6\7u\2\2\u01b2\u01b3\7H\2\2\u01b3\u01b5\7u\2\2\u01b4\u01b2"+ - "\3\2\2\2\u01b5\u01b8\3\2\2\2\u01b6\u01b4\3\2\2\2\u01b6\u01b7\3\2\2\2\u01b7"+ - "?\3\2\2\2\u01b8\u01b6\3\2\2\2\u01b9\u01ba\t\f\2\2\u01baA\3\2\2\2\u01bb"+ - "\u01bc\t\r\2\2\u01bcC\3\2\2\2\u01bd\u01be\t\16\2\2\u01beE\3\2\2\2\u01bf"+ - "\u01c1\t\17\2\2\u01c0\u01c2\5H%\2\u01c1\u01c0\3\2\2\2\u01c1\u01c2\3\2"+ - "\2\2\u01c2G\3\2\2\2\u01c3\u01c4\7S\2\2\u01c4I\3\2\2\2\u01c5\u01c6\t\20"+ - "\2\2\u01c6K\3\2\2\2\u01c7\u01c9\7\33\2\2\u01c8\u01ca\7t\2\2\u01c9\u01c8"+ - "\3\2\2\2\u01c9\u01ca\3\2\2\2\u01ca\u01cb\3\2\2\2\u01cb\u01d3\5(\25\2\u01cc"+ - "\u01ce\7\20\2\2\u01cd\u01cf\7t\2\2\u01ce\u01cd\3\2\2\2\u01ce\u01cf\3\2"+ - "\2\2\u01cf\u01d0\3\2\2\2\u01d0\u01d2\5(\25\2\u01d1\u01cc\3\2\2\2\u01d2"+ - "\u01d5\3\2\2\2\u01d3\u01d1\3\2\2\2\u01d3\u01d4\3\2\2\2\u01d4\u01d7\3\2"+ - "\2\2\u01d5\u01d3\3\2\2\2\u01d6\u01d8\7t\2\2\u01d7\u01d6\3\2\2\2\u01d7"+ - "\u01d8\3\2\2\2\u01d8\u01d9\3\2\2\2\u01d9\u01da\7\34\2\2\u01daM\3\2\2\2"+ - "\u01db\u01dc\7z\2\2\u01dcO\3\2\2\2\u01dd\u01de\7|\2\2\u01deQ\3\2\2\2\u01df"+ - "\u01e0\7y\2\2\u01e0S\3\2\2\2\u01e1\u01e8\5F$\2\u01e2\u01e8\5J&\2\u01e3"+ - "\u01e8\5L\'\2\u01e4\u01e8\5N(\2\u01e5\u01e8\5P)\2\u01e6\u01e8\5R*\2\u01e7"+ - "\u01e1\3\2\2\2\u01e7\u01e2\3\2\2\2\u01e7\u01e3\3\2\2\2\u01e7\u01e4\3\2"+ - "\2\2\u01e7\u01e5\3\2\2\2\u01e7\u01e6\3\2\2\2\u01e8U\3\2\2\2\u01e9\u01ea"+ - "\7V\2\2\u01ea\u01eb\7{\2\2\u01ebW\3\2\2\2\u01ec\u01ed\7W\2\2\u01ed\u01ee"+ - "\5<\37\2\u01ee\u01f0\7A\2\2\u01ef\u01f1\5^\60\2\u01f0\u01ef\3\2\2\2\u01f0"+ - "\u01f1\3\2\2\2\u01f1\u01f2\3\2\2\2\u01f2\u01f4\7B\2\2\u01f3\u01f5\5Z."+ - "\2\u01f4\u01f3\3\2\2\2\u01f4\u01f5\3\2\2\2\u01f5\u01f6\3\2\2\2\u01f6\u01f7"+ - "\5\\/\2\u01f7\u01f8\7t\2\2\u01f8Y\3\2\2\2\u01f9\u01fa\7X\2\2\u01fa\u01fb"+ - "\5`\61\2\u01fb[\3\2\2\2\u01fc\u01fd\7Y\2\2\u01fd\u0202\7t\2\2\u01fe\u0201"+ - "\5\b\5\2\u01ff\u0201\7t\2\2\u0200\u01fe\3\2\2\2\u0200\u01ff\3\2\2\2\u0201"+ - "\u0204\3\2\2\2\u0202\u0200\3\2\2\2\u0202\u0203\3\2\2\2\u0203\u0205\3\2"+ - "\2\2\u0204\u0202\3\2\2\2\u0205\u0206\7Z\2\2\u0206]\3\2\2\2\u0207\u020f"+ - "\5\22\n\2\u0208\u020a\7\20\2\2\u0209\u020b\7t\2\2\u020a\u0209\3\2\2\2"+ - "\u020a\u020b\3\2\2\2\u020b\u020c\3\2\2\2\u020c\u020e\5\22\n\2\u020d\u0208"+ - "\3\2\2\2\u020e\u0211\3\2\2\2\u020f\u020d\3\2\2\2\u020f\u0210\3\2\2\2\u0210"+ - "_\3\2\2\2\u0211\u020f\3\2\2\2\u0212\u021a\5\32\16\2\u0213\u0215\7\20\2"+ - "\2\u0214\u0216\7t\2\2\u0215\u0214\3\2\2\2\u0215\u0216\3\2\2\2\u0216\u0217"+ - "\3\2\2\2\u0217\u0219\5\32\16\2\u0218\u0213\3\2\2\2\u0219\u021c\3\2\2\2"+ - "\u021a\u0218\3\2\2\2\u021a\u021b\3\2\2\2\u021ba\3\2\2\2\u021c\u021a\3"+ - "\2\2\2\u021d\u021e\7[\2\2\u021e\u021f\5<\37\2\u021f\u0221\7A\2\2\u0220"+ - "\u0222\5f\64\2\u0221\u0220\3\2\2\2\u0221\u0222\3\2\2\2\u0222\u0223\3\2"+ - "\2\2\u0223\u0224\7B\2\2\u0224\u0225\7X\2\2\u0225\u0226\7\\\2\2\u0226\u0228"+ - "\7A\2\2\u0227\u0229\5j\66\2\u0228\u0227\3\2\2\2\u0228\u0229\3\2\2\2\u0229"+ - "\u022a\3\2\2\2\u022a\u022b\7B\2\2\u022b\u022c\7X\2\2\u022c\u022e\7A\2"+ + "\4>\t>\4?\t?\4@\t@\3\2\3\2\7\2\u0083\n\2\f\2\16\2\u0086\13\2\3\2\3\2\3"+ + "\3\3\3\5\3\u008c\n\3\3\4\3\4\3\4\5\4\u0091\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\u00ac\n\5\3\6\3\6\3\6\3\7\3\7\3\7\5\7\u00b4\n\7\3\b\3\b\5\b"+ + "\u00b8\n\b\3\b\3\b\3\b\7\b\u00bd\n\b\f\b\16\b\u00c0\13\b\5\b\u00c2\n\b"+ + "\3\t\3\t\3\t\5\t\u00c7\n\t\3\n\3\n\5\n\u00cb\n\n\3\n\5\n\u00ce\n\n\3\n"+ + "\3\n\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\u00e9\n\21\f\21\16\21"+ + "\u00ec\13\21\3\22\3\22\3\22\3\22\3\23\3\23\3\23\3\23\5\23\u00f6\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\3\25\5\25\u010b\n\25\3\25\3\25\5\25\u010f\n\25\3\25"+ + "\3\25\5\25\u0113\n\25\3\25\3\25\3\25\5\25\u0118\n\25\3\25\3\25\5\25\u011c"+ + "\n\25\3\25\3\25\3\25\5\25\u0121\n\25\3\25\3\25\5\25\u0125\n\25\3\25\3"+ + "\25\3\25\5\25\u012a\n\25\3\25\3\25\5\25\u012e\n\25\3\25\3\25\3\25\5\25"+ + "\u0133\n\25\3\25\3\25\5\25\u0137\n\25\3\25\3\25\3\25\5\25\u013c\n\25\3"+ + "\25\3\25\5\25\u0140\n\25\3\25\3\25\3\25\5\25\u0145\n\25\3\25\3\25\5\25"+ + "\u0149\n\25\3\25\3\25\3\25\5\25\u014e\n\25\3\25\3\25\5\25\u0152\n\25\3"+ + "\25\3\25\3\25\5\25\u0157\n\25\3\25\3\25\5\25\u015b\n\25\3\25\3\25\3\25"+ + "\5\25\u0160\n\25\3\25\3\25\5\25\u0164\n\25\3\25\3\25\3\25\5\25\u0169\n"+ + "\25\3\25\3\25\5\25\u016d\n\25\3\25\3\25\3\25\5\25\u0172\n\25\3\25\3\25"+ + "\5\25\u0176\n\25\3\25\3\25\3\25\3\25\3\25\3\25\5\25\u017e\n\25\3\25\3"+ + "\25\7\25\u0182\n\25\f\25\16\25\u0185\13\25\3\26\3\26\3\26\3\27\3\27\3"+ + "\27\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\32\3\32\3\32\5\32\u0198"+ + "\n\32\3\32\3\32\3\33\3\33\3\33\5\33\u019f\n\33\3\33\3\33\3\34\3\34\3\34"+ + "\5\34\u01a6\n\34\3\34\7\34\u01a9\n\34\f\34\16\34\u01ac\13\34\3\35\3\35"+ + "\5\35\u01b0\n\35\3\36\3\36\3\37\3\37\3 \3 \3!\3!\3!\7!\u01bb\n!\f!\16"+ + "!\u01be\13!\3\"\3\"\3#\3#\3$\3$\3%\3%\5%\u01c8\n%\3&\3&\3\'\3\'\3(\3("+ + "\5(\u01d0\n(\3(\3(\3(\5(\u01d5\n(\3(\7(\u01d8\n(\f(\16(\u01db\13(\3(\5"+ + "(\u01de\n(\3(\3(\3)\3)\3*\3*\3+\3+\3,\3,\3,\3,\3,\3,\5,\u01ee\n,\3-\3"+ + "-\3-\3.\3.\3.\3.\5.\u01f7\n.\3.\3.\5.\u01fb\n.\3.\3.\3.\3/\3/\3/\3\60"+ + "\3\60\3\60\3\60\7\60\u0207\n\60\f\60\16\60\u020a\13\60\3\60\3\60\3\61"+ + "\3\61\3\61\5\61\u0211\n\61\3\61\7\61\u0214\n\61\f\61\16\61\u0217\13\61"+ + "\3\62\3\62\3\62\5\62\u021c\n\62\3\62\7\62\u021f\n\62\f\62\16\62\u0222"+ + "\13\62\3\63\3\63\3\63\3\63\5\63\u0228\n\63\3\63\3\63\3\63\3\63\3\63\5"+ + "\63\u022f\n\63\3\63\3\63\3\63\3\63\5\63\u0235\n\63\3\63\3\63\3\63\5\63"+ + "\u023a\n\63\3\64\3\64\3\64\3\65\3\65\3\65\5\65\u0242\n\65\3\65\7\65\u0245"+ + "\n\65\f\65\16\65\u0248\13\65\3\66\3\66\3\66\3\66\3\66\5\66\u024f\n\66"+ + "\3\67\3\67\3\67\7\67\u0254\n\67\f\67\16\67\u0257\13\67\38\38\38\58\u025c"+ + "\n8\38\78\u025f\n8\f8\168\u0262\138\39\39\39\39\39\59\u0269\n9\3:\3:\3"+ + ":\5:\u026e\n:\3:\3:\5:\u0272\n:\3:\5:\u0275\n:\3:\5:\u0278\n:\3;\3;\5"+ + ";\u027c\n;\3;\3;\5;\u0280\n;\3<\3<\5<\u0284\n<\3<\3<\5<\u0288\n<\3<\5"+ + "<\u028b\n<\3<\5<\u028e\n<\3<\3<\3=\3=\3>\3>\5>\u0296\n>\3>\5>\u0299\n"+ + ">\3>\3>\5>\u029d\n>\3>\3>\3>\5>\u02a2\n>\3>\3>\5>\u02a6\n>\3?\3?\3?\5"+ + "?\u02ab\n?\3?\3?\5?\u02af\n?\3@\3@\3@\5@\u02b4\n@\3@\5@\u02b7\n@\3@\3"+ + "@\3@\3@\2\3(A\2\4\6\b\n\f\16\20\22\24\26\30\32\34\36 \"$&(*,.\60\62\64"+ + "\668:<>@BDFHJLNPRTVXZ\\^`bdfhjlnprtvxz|~\2\22\3\2\6\17\3\2\24\32\3\2\35"+ + "\'\3\2()\4\2\3\3*+\3\2-/\3\2*+\3\2\60\61\3\2\62\65\3\2\66\67\3\2IK\3\2"+ + "IN\3\2OR\3\2vx\3\2TU\3\2`k\2\u0309\2\u0084\3\2\2\2\4\u008b\3\2\2\2\6\u008d"+ + "\3\2\2\2\b\u00ab\3\2\2\2\n\u00ad\3\2\2\2\f\u00b0\3\2\2\2\16\u00b5\3\2"+ + "\2\2\20\u00c6\3\2\2\2\22\u00c8\3\2\2\2\24\u00d1\3\2\2\2\26\u00d5\3\2\2"+ + "\2\30\u00d8\3\2\2\2\32\u00db\3\2\2\2\34\u00dd\3\2\2\2\36\u00e1\3\2\2\2"+ + " \u00e5\3\2\2\2\"\u00ed\3\2\2\2$\u00f5\3\2\2\2&\u00f7\3\2\2\2(\u010a\3"+ + "\2\2\2*\u0186\3\2\2\2,\u0189\3\2\2\2.\u018c\3\2\2\2\60\u0191\3\2\2\2\62"+ + "\u0194\3\2\2\2\64\u019b\3\2\2\2\66\u01a2\3\2\2\28\u01ad\3\2\2\2:\u01b1"+ + "\3\2\2\2<\u01b3\3\2\2\2>\u01b5\3\2\2\2@\u01b7\3\2\2\2B\u01bf\3\2\2\2D"+ + "\u01c1\3\2\2\2F\u01c3\3\2\2\2H\u01c5\3\2\2\2J\u01c9\3\2\2\2L\u01cb\3\2"+ + "\2\2N\u01cd\3\2\2\2P\u01e1\3\2\2\2R\u01e3\3\2\2\2T\u01e5\3\2\2\2V\u01ed"+ + "\3\2\2\2X\u01ef\3\2\2\2Z\u01f2\3\2\2\2\\\u01ff\3\2\2\2^\u0202\3\2\2\2"+ + "`\u020d\3\2\2\2b\u0218\3\2\2\2d\u0223\3\2\2\2f\u023b\3\2\2\2h\u023e\3"+ + "\2\2\2j\u0249\3\2\2\2l\u0250\3\2\2\2n\u0258\3\2\2\2p\u0263\3\2\2\2r\u026a"+ + "\3\2\2\2t\u0279\3\2\2\2v\u0281\3\2\2\2x\u0291\3\2\2\2z\u0293\3\2\2\2|"+ + "\u02a7\3\2\2\2~\u02b0\3\2\2\2\u0080\u0083\5\4\3\2\u0081\u0083\7t\2\2\u0082"+ + "\u0080\3\2\2\2\u0082\u0081\3\2\2\2\u0083\u0086\3\2\2\2\u0084\u0082\3\2"+ + "\2\2\u0084\u0085\3\2\2\2\u0085\u0087\3\2\2\2\u0086\u0084\3\2\2\2\u0087"+ + "\u0088\7\2\2\3\u0088\3\3\2\2\2\u0089\u008c\5\16\b\2\u008a\u008c\5\6\4"+ + "\2\u008b\u0089\3\2\2\2\u008b\u008a\3\2\2\2\u008c\5\3\2\2\2\u008d\u008e"+ + "\7\3\2\2\u008e\u0090\5> \2\u008f\u0091\5H%\2\u0090\u008f\3\2\2\2\u0090"+ + "\u0091\3\2\2\2\u0091\u0092\3\2\2\2\u0092\u0093\5^\60\2\u0093\u0094\7t"+ + "\2\2\u0094\7\3\2\2\2\u0095\u00ac\5\16\b\2\u0096\u00ac\5\24\13\2\u0097"+ + "\u00ac\5\22\n\2\u0098\u00ac\5\26\f\2\u0099\u00ac\5\30\r\2\u009a\u00ac"+ + "\5\36\20\2\u009b\u00ac\5\"\22\2\u009c\u00ac\5\f\7\2\u009d\u00ac\5&\24"+ + "\2\u009e\u00ac\5\64\33\2\u009f\u00ac\5r:\2\u00a0\u00ac\5v<\2\u00a1\u00ac"+ + "\5Z.\2\u00a2\u00ac\5d\63\2\u00a3\u00ac\5X-\2\u00a4\u00ac\58\35\2\u00a5"+ + "\u00ac\5z>\2\u00a6\u00ac\5|?\2\u00a7\u00ac\5~@\2\u00a8\u00ac\5:\36\2\u00a9"+ + "\u00ac\5<\37\2\u00aa\u00ac\5\n\6\2\u00ab\u0095\3\2\2\2\u00ab\u0096\3\2"+ + "\2\2\u00ab\u0097\3\2\2\2\u00ab\u0098\3\2\2\2\u00ab\u0099\3\2\2\2\u00ab"+ + "\u009a\3\2\2\2\u00ab\u009b\3\2\2\2\u00ab\u009c\3\2\2\2\u00ab\u009d\3\2"+ + "\2\2\u00ab\u009e\3\2\2\2\u00ab\u009f\3\2\2\2\u00ab\u00a0\3\2\2\2\u00ab"+ + "\u00a1\3\2\2\2\u00ab\u00a2\3\2\2\2\u00ab\u00a3\3\2\2\2\u00ab\u00a4\3\2"+ + "\2\2\u00ab\u00a5\3\2\2\2\u00ab\u00a6\3\2\2\2\u00ab\u00a7\3\2\2\2\u00ab"+ + "\u00a8\3\2\2\2\u00ab\u00a9\3\2\2\2\u00ab\u00aa\3\2\2\2\u00ac\t\3\2\2\2"+ + "\u00ad\u00ae\5> \2\u00ae\u00af\7\4\2\2\u00af\13\3\2\2\2\u00b0\u00b3\7"+ + "\5\2\2\u00b1\u00b4\5H%\2\u00b2\u00b4\5@!\2\u00b3\u00b1\3\2\2\2\u00b3\u00b2"+ + "\3\2\2\2\u00b4\r\3\2\2\2\u00b5\u00c1\t\2\2\2\u00b6\u00b8\5\20\t\2\u00b7"+ + "\u00b6\3\2\2\2\u00b7\u00b8\3\2\2\2\u00b8\u00c2\3\2\2\2\u00b9\u00be\5\20"+ + "\t\2\u00ba\u00bb\7\20\2\2\u00bb\u00bd\5\20\t\2\u00bc\u00ba\3\2\2\2\u00bd"+ + "\u00c0\3\2\2\2\u00be\u00bc\3\2\2\2\u00be\u00bf\3\2\2\2\u00bf\u00c2\3\2"+ + "\2\2\u00c0\u00be\3\2\2\2\u00c1\u00b7\3\2\2\2\u00c1\u00b9\3\2\2\2\u00c2"+ + "\17\3\2\2\2\u00c3\u00c7\5P)\2\u00c4\u00c7\5> \2\u00c5\u00c7\5H%\2\u00c6"+ + "\u00c3\3\2\2\2\u00c6\u00c4\3\2\2\2\u00c6\u00c5\3\2\2\2\u00c7\21\3\2\2"+ + "\2\u00c8\u00ca\5\32\16\2\u00c9\u00cb\7}\2\2\u00ca\u00c9\3\2\2\2\u00ca"+ + "\u00cb\3\2\2\2\u00cb\u00cd\3\2\2\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\5> \2\u00d0"+ + "\23\3\2\2\2\u00d1\u00d2\5\22\n\2\u00d2\u00d3\7\21\2\2\u00d3\u00d4\5(\25"+ + "\2\u00d4\25\3\2\2\2\u00d5\u00d6\7\22\2\2\u00d6\u00d7\5\24\13\2\u00d7\27"+ + "\3\2\2\2\u00d8\u00d9\7\23\2\2\u00d9\u00da\5\24\13\2\u00da\31\3\2\2\2\u00db"+ + "\u00dc\t\3\2\2\u00dc\33\3\2\2\2\u00dd\u00de\7\33\2\2\u00de\u00df\5(\25"+ + "\2\u00df\u00e0\7\34\2\2\u00e0\35\3\2\2\2\u00e1\u00e2\5 \21\2\u00e2\u00e3"+ + "\7\21\2\2\u00e3\u00e4\5(\25\2\u00e4\37\3\2\2\2\u00e5\u00ea\5$\23\2\u00e6"+ + "\u00e7\7\20\2\2\u00e7\u00e9\5$\23\2\u00e8\u00e6\3\2\2\2\u00e9\u00ec\3"+ + "\2\2\2\u00ea\u00e8\3\2\2\2\u00ea\u00eb\3\2\2\2\u00eb!\3\2\2\2\u00ec\u00ea"+ + "\3\2\2\2\u00ed\u00ee\5$\23\2\u00ee\u00ef\t\4\2\2\u00ef\u00f0\5(\25\2\u00f0"+ + "#\3\2\2\2\u00f1\u00f6\5B\"\2\u00f2\u00f6\5@!\2\u00f3\u00f6\5,\27\2\u00f4"+ + "\u00f6\5.\30\2\u00f5\u00f1\3\2\2\2\u00f5\u00f2\3\2\2\2\u00f5\u00f3\3\2"+ + "\2\2\u00f5\u00f4\3\2\2\2\u00f6%\3\2\2\2\u00f7\u00f8\5$\23\2\u00f8\u00f9"+ + "\t\5\2\2\u00f9\'\3\2\2\2\u00fa\u00fb\b\25\1\2\u00fb\u010b\5\62\32\2\u00fc"+ + "\u00fd\t\6\2\2\u00fd\u010b\5(\25\31\u00fe\u00ff\7@\2\2\u00ff\u010b\5("+ + "\25\13\u0100\u010b\5V,\2\u0101\u010b\5B\"\2\u0102\u010b\5@!\2\u0103\u010b"+ + "\5,\27\2\u0104\u010b\5.\30\2\u0105\u010b\5\60\31\2\u0106\u0107\7A\2\2"+ + "\u0107\u0108\5(\25\2\u0108\u0109\7B\2\2\u0109\u010b\3\2\2\2\u010a\u00fa"+ + "\3\2\2\2\u010a\u00fc\3\2\2\2\u010a\u00fe\3\2\2\2\u010a\u0100\3\2\2\2\u010a"+ + "\u0101\3\2\2\2\u010a\u0102\3\2\2\2\u010a\u0103\3\2\2\2\u010a\u0104\3\2"+ + "\2\2\u010a\u0105\3\2\2\2\u010a\u0106\3\2\2\2\u010b\u0183\3\2\2\2\u010c"+ + "\u010e\f\30\2\2\u010d\u010f\7t\2\2\u010e\u010d\3\2\2\2\u010e\u010f\3\2"+ + "\2\2\u010f\u0110\3\2\2\2\u0110\u0112\7,\2\2\u0111\u0113\7t\2\2\u0112\u0111"+ + "\3\2\2\2\u0112\u0113\3\2\2\2\u0113\u0114\3\2\2\2\u0114\u0182\5(\25\31"+ + "\u0115\u0117\f\27\2\2\u0116\u0118\7t\2\2\u0117\u0116\3\2\2\2\u0117\u0118"+ + "\3\2\2\2\u0118\u0119\3\2\2\2\u0119\u011b\t\7\2\2\u011a\u011c\7t\2\2\u011b"+ + "\u011a\3\2\2\2\u011b\u011c\3\2\2\2\u011c\u011d\3\2\2\2\u011d\u0182\5("+ + "\25\30\u011e\u0120\f\26\2\2\u011f\u0121\7t\2\2\u0120\u011f\3\2\2\2\u0120"+ + "\u0121\3\2\2\2\u0121\u0122\3\2\2\2\u0122\u0124\t\b\2\2\u0123\u0125\7t"+ + "\2\2\u0124\u0123\3\2\2\2\u0124\u0125\3\2\2\2\u0125\u0126\3\2\2\2\u0126"+ + "\u0182\5(\25\27\u0127\u0129\f\25\2\2\u0128\u012a\7t\2\2\u0129\u0128\3"+ + "\2\2\2\u0129\u012a\3\2\2\2\u012a\u012b\3\2\2\2\u012b\u012d\t\t\2\2\u012c"+ + "\u012e\7t\2\2\u012d\u012c\3\2\2\2\u012d\u012e\3\2\2\2\u012e\u012f\3\2"+ + "\2\2\u012f\u0182\5(\25\26\u0130\u0132\f\24\2\2\u0131\u0133\7t\2\2\u0132"+ + "\u0131\3\2\2\2\u0132\u0133\3\2\2\2\u0133\u0134\3\2\2\2\u0134\u0136\t\n"+ + "\2\2\u0135\u0137\7t\2\2\u0136\u0135\3\2\2\2\u0136\u0137\3\2\2\2\u0137"+ + "\u0138\3\2\2\2\u0138\u0182\5(\25\25\u0139\u013b\f\23\2\2\u013a\u013c\7"+ + "t\2\2\u013b\u013a\3\2\2\2\u013b\u013c\3\2\2\2\u013c\u013d\3\2\2\2\u013d"+ + "\u013f\t\13\2\2\u013e\u0140\7t\2\2\u013f\u013e\3\2\2\2\u013f\u0140\3\2"+ + "\2\2\u0140\u0141\3\2\2\2\u0141\u0182\5(\25\24\u0142\u0144\f\22\2\2\u0143"+ + "\u0145\7t\2\2\u0144\u0143\3\2\2\2\u0144\u0145\3\2\2\2\u0145\u0146\3\2"+ + "\2\2\u0146\u0148\78\2\2\u0147\u0149\7t\2\2\u0148\u0147\3\2\2\2\u0148\u0149"+ + "\3\2\2\2\u0149\u014a\3\2\2\2\u014a\u0182\5(\25\23\u014b\u014d\f\21\2\2"+ + "\u014c\u014e\7t\2\2\u014d\u014c\3\2\2\2\u014d\u014e\3\2\2\2\u014e\u014f"+ + "\3\2\2\2\u014f\u0151\79\2\2\u0150\u0152\7t\2\2\u0151\u0150\3\2\2\2\u0151"+ + "\u0152\3\2\2\2\u0152\u0153\3\2\2\2\u0153\u0182\5(\25\22\u0154\u0156\f"+ + "\20\2\2\u0155\u0157\7t\2\2\u0156\u0155\3\2\2\2\u0156\u0157\3\2\2\2\u0157"+ + "\u0158\3\2\2\2\u0158\u015a\7:\2\2\u0159\u015b\7t\2\2\u015a\u0159\3\2\2"+ + "\2\u015a\u015b\3\2\2\2\u015b\u015c\3\2\2\2\u015c\u0182\5(\25\21\u015d"+ + "\u015f\f\16\2\2\u015e\u0160\7t\2\2\u015f\u015e\3\2\2\2\u015f\u0160\3\2"+ + "\2\2\u0160\u0161\3\2\2\2\u0161\u0163\7=\2\2\u0162\u0164\7t\2\2\u0163\u0162"+ + "\3\2\2\2\u0163\u0164\3\2\2\2\u0164\u0165\3\2\2\2\u0165\u0182\5(\25\17"+ + "\u0166\u0168\f\r\2\2\u0167\u0169\7t\2\2\u0168\u0167\3\2\2\2\u0168\u0169"+ + "\3\2\2\2\u0169\u016a\3\2\2\2\u016a\u016c\7>\2\2\u016b\u016d\7t\2\2\u016c"+ + "\u016b\3\2\2\2\u016c\u016d\3\2\2\2\u016d\u016e\3\2\2\2\u016e\u0182\5("+ + "\25\16\u016f\u0171\f\f\2\2\u0170\u0172\7t\2\2\u0171\u0170\3\2\2\2\u0171"+ + "\u0172\3\2\2\2\u0172\u0173\3\2\2\2\u0173\u0175\7?\2\2\u0174\u0176\7t\2"+ + "\2\u0175\u0174\3\2\2\2\u0175\u0176\3\2\2\2\u0176\u0177\3\2\2\2\u0177\u0182"+ + "\5(\25\r\u0178\u0179\f\17\2\2\u0179\u017a\7;\2\2\u017a\u017d\5(\25\2\u017b"+ + "\u017c\7<\2\2\u017c\u017e\5(\25\2\u017d\u017b\3\2\2\2\u017d\u017e\3\2"+ + "\2\2\u017e\u0182\3\2\2\2\u017f\u0180\f\4\2\2\u0180\u0182\5*\26\2\u0181"+ + "\u010c\3\2\2\2\u0181\u0115\3\2\2\2\u0181\u011e\3\2\2\2\u0181\u0127\3\2"+ + "\2\2\u0181\u0130\3\2\2\2\u0181\u0139\3\2\2\2\u0181\u0142\3\2\2\2\u0181"+ + "\u014b\3\2\2\2\u0181\u0154\3\2\2\2\u0181\u015d\3\2\2\2\u0181\u0166\3\2"+ + "\2\2\u0181\u016f\3\2\2\2\u0181\u0178\3\2\2\2\u0181\u017f\3\2\2\2\u0182"+ + "\u0185\3\2\2\2\u0183\u0181\3\2\2\2\u0183\u0184\3\2\2\2\u0184)\3\2\2\2"+ + "\u0185\u0183\3\2\2\2\u0186\u0187\7C\2\2\u0187\u0188\5\32\16\2\u0188+\3"+ + "\2\2\2\u0189\u018a\5@!\2\u018a\u018b\5\34\17\2\u018b-\3\2\2\2\u018c\u018d"+ + "\7D\2\2\u018d\u018e\7A\2\2\u018e\u018f\5(\25\2\u018f\u0190\7B\2\2\u0190"+ + "/\3\2\2\2\u0191\u0192\78\2\2\u0192\u0193\5@!\2\u0193\61\3\2\2\2\u0194"+ + "\u0195\5@!\2\u0195\u0197\7A\2\2\u0196\u0198\5\66\34\2\u0197\u0196\3\2"+ + "\2\2\u0197\u0198\3\2\2\2\u0198\u0199\3\2\2\2\u0199\u019a\7B\2\2\u019a"+ + "\63\3\2\2\2\u019b\u019c\5@!\2\u019c\u019e\7A\2\2\u019d\u019f\5\66\34\2"+ + "\u019e\u019d\3\2\2\2\u019e\u019f\3\2\2\2\u019f\u01a0\3\2\2\2\u01a0\u01a1"+ + "\7B\2\2\u01a1\65\3\2\2\2\u01a2\u01aa\5(\25\2\u01a3\u01a5\7\20\2\2\u01a4"+ + "\u01a6\7t\2\2\u01a5\u01a4\3\2\2\2\u01a5\u01a6\3\2\2\2\u01a6\u01a7\3\2"+ + "\2\2\u01a7\u01a9\5(\25\2\u01a8\u01a3\3\2\2\2\u01a9\u01ac\3\2\2\2\u01aa"+ + "\u01a8\3\2\2\2\u01aa\u01ab\3\2\2\2\u01ab\67\3\2\2\2\u01ac\u01aa\3\2\2"+ + "\2\u01ad\u01af\7E\2\2\u01ae\u01b0\5\66\34\2\u01af\u01ae\3\2\2\2\u01af"+ + "\u01b0\3\2\2\2\u01b09\3\2\2\2\u01b1\u01b2\7F\2\2\u01b2;\3\2\2\2\u01b3"+ + "\u01b4\7G\2\2\u01b4=\3\2\2\2\u01b5\u01b6\7u\2\2\u01b6?\3\2\2\2\u01b7\u01bc"+ + "\7u\2\2\u01b8\u01b9\7H\2\2\u01b9\u01bb\7u\2\2\u01ba\u01b8\3\2\2\2\u01bb"+ + "\u01be\3\2\2\2\u01bc\u01ba\3\2\2\2\u01bc\u01bd\3\2\2\2\u01bdA\3\2\2\2"+ + "\u01be\u01bc\3\2\2\2\u01bf\u01c0\t\f\2\2\u01c0C\3\2\2\2\u01c1\u01c2\t"+ + "\r\2\2\u01c2E\3\2\2\2\u01c3\u01c4\t\16\2\2\u01c4G\3\2\2\2\u01c5\u01c7"+ + "\t\17\2\2\u01c6\u01c8\5J&\2\u01c7\u01c6\3\2\2\2\u01c7\u01c8\3\2\2\2\u01c8"+ + "I\3\2\2\2\u01c9\u01ca\7S\2\2\u01caK\3\2\2\2\u01cb\u01cc\t\20\2\2\u01cc"+ + "M\3\2\2\2\u01cd\u01cf\7\33\2\2\u01ce\u01d0\7t\2\2\u01cf\u01ce\3\2\2\2"+ + "\u01cf\u01d0\3\2\2\2\u01d0\u01d1\3\2\2\2\u01d1\u01d9\5(\25\2\u01d2\u01d4"+ + "\7\20\2\2\u01d3\u01d5\7t\2\2\u01d4\u01d3\3\2\2\2\u01d4\u01d5\3\2\2\2\u01d5"+ + "\u01d6\3\2\2\2\u01d6\u01d8\5(\25\2\u01d7\u01d2\3\2\2\2\u01d8\u01db\3\2"+ + "\2\2\u01d9\u01d7\3\2\2\2\u01d9\u01da\3\2\2\2\u01da\u01dd\3\2\2\2\u01db"+ + "\u01d9\3\2\2\2\u01dc\u01de\7t\2\2\u01dd\u01dc\3\2\2\2\u01dd\u01de\3\2"+ + "\2\2\u01de\u01df\3\2\2\2\u01df\u01e0\7\34\2\2\u01e0O\3\2\2\2\u01e1\u01e2"+ + "\7z\2\2\u01e2Q\3\2\2\2\u01e3\u01e4\7|\2\2\u01e4S\3\2\2\2\u01e5\u01e6\7"+ + "y\2\2\u01e6U\3\2\2\2\u01e7\u01ee\5H%\2\u01e8\u01ee\5L\'\2\u01e9\u01ee"+ + "\5N(\2\u01ea\u01ee\5P)\2\u01eb\u01ee\5R*\2\u01ec\u01ee\5T+\2\u01ed\u01e7"+ + "\3\2\2\2\u01ed\u01e8\3\2\2\2\u01ed\u01e9\3\2\2\2\u01ed\u01ea\3\2\2\2\u01ed"+ + "\u01eb\3\2\2\2\u01ed\u01ec\3\2\2\2\u01eeW\3\2\2\2\u01ef\u01f0\7V\2\2\u01f0"+ + "\u01f1\7{\2\2\u01f1Y\3\2\2\2\u01f2\u01f3\7W\2\2\u01f3\u01f4\5> \2\u01f4"+ + "\u01f6\7A\2\2\u01f5\u01f7\5`\61\2\u01f6\u01f5\3\2\2\2\u01f6\u01f7\3\2"+ + "\2\2\u01f7\u01f8\3\2\2\2\u01f8\u01fa\7B\2\2\u01f9\u01fb\5\\/\2\u01fa\u01f9"+ + "\3\2\2\2\u01fa\u01fb\3\2\2\2\u01fb\u01fc\3\2\2\2\u01fc\u01fd\5^\60\2\u01fd"+ + "\u01fe\7t\2\2\u01fe[\3\2\2\2\u01ff\u0200\7X\2\2\u0200\u0201\5b\62\2\u0201"+ + "]\3\2\2\2\u0202\u0203\7Y\2\2\u0203\u0208\7t\2\2\u0204\u0207\5\b\5\2\u0205"+ + "\u0207\7t\2\2\u0206\u0204\3\2\2\2\u0206\u0205\3\2\2\2\u0207\u020a\3\2"+ + "\2\2\u0208\u0206\3\2\2\2\u0208\u0209\3\2\2\2\u0209\u020b\3\2\2\2\u020a"+ + "\u0208\3\2\2\2\u020b\u020c\7Z\2\2\u020c_\3\2\2\2\u020d\u0215\5\22\n\2"+ + "\u020e\u0210\7\20\2\2\u020f\u0211\7t\2\2\u0210\u020f\3\2\2\2\u0210\u0211"+ + "\3\2\2\2\u0211\u0212\3\2\2\2\u0212\u0214\5\22\n\2\u0213\u020e\3\2\2\2"+ + "\u0214\u0217\3\2\2\2\u0215\u0213\3\2\2\2\u0215\u0216\3\2\2\2\u0216a\3"+ + "\2\2\2\u0217\u0215\3\2\2\2\u0218\u0220\5\32\16\2\u0219\u021b\7\20\2\2"+ + "\u021a\u021c\7t\2\2\u021b\u021a\3\2\2\2\u021b\u021c\3\2\2\2\u021c\u021d"+ + "\3\2\2\2\u021d\u021f\5\32\16\2\u021e\u0219\3\2\2\2\u021f\u0222\3\2\2\2"+ + "\u0220\u021e\3\2\2\2\u0220\u0221\3\2\2\2\u0221c\3\2\2\2\u0222\u0220\3"+ + "\2\2\2\u0223\u0224\7[\2\2\u0224\u0225\5> \2\u0225\u0227\7A\2\2\u0226\u0228"+ + "\5h\65\2\u0227\u0226\3\2\2\2\u0227\u0228\3\2\2\2\u0228\u0229\3\2\2\2\u0229"+ + "\u022a\7B\2\2\u022a\u022b\7X\2\2\u022b\u022c\7\\\2\2\u022c\u022e\7A\2"+ "\2\u022d\u022f\5l\67\2\u022e\u022d\3\2\2\2\u022e\u022f\3\2\2\2\u022f\u0230"+ - "\3\2\2\2\u0230\u0233\7B\2\2\u0231\u0234\5d\63\2\u0232\u0234\5\\/\2\u0233"+ - "\u0231\3\2\2\2\u0233\u0232\3\2\2\2\u0234c\3\2\2\2\u0235\u0236\7\21\2\2"+ - "\u0236\u0237\5F$\2\u0237e\3\2\2\2\u0238\u0240\5h\65\2\u0239\u023b\7\20"+ - "\2\2\u023a\u023c\7t\2\2\u023b\u023a\3\2\2\2\u023b\u023c\3\2\2\2\u023c"+ - "\u023d\3\2\2\2\u023d\u023f\5h\65\2\u023e\u0239\3\2\2\2\u023f\u0242\3\2"+ - "\2\2\u0240\u023e\3\2\2\2\u0240\u0241\3\2\2\2\u0241g\3\2\2\2\u0242\u0240"+ - "\3\2\2\2\u0243\u0244\5\22\n\2\u0244\u0248\7D\2\2\u0245\u0249\5B\"\2\u0246"+ - "\u0249\5D#\2\u0247\u0249\7]\2\2\u0248\u0245\3\2\2\2\u0248\u0246\3\2\2"+ - "\2\u0248\u0247\3\2\2\2\u0249i\3\2\2\2\u024a\u024f\5@!\2\u024b\u024c\7"+ - "\20\2\2\u024c\u024e\5@!\2\u024d\u024b\3\2\2\2\u024e\u0251\3\2\2\2\u024f"+ - "\u024d\3\2\2\2\u024f\u0250\3\2\2\2\u0250k\3\2\2\2\u0251\u024f\3\2\2\2"+ - "\u0252\u025a\5n8\2\u0253\u0255\7\20\2\2\u0254\u0256\7t\2\2\u0255\u0254"+ - "\3\2\2\2\u0255\u0256\3\2\2\2\u0256\u0257\3\2\2\2\u0257\u0259\5n8\2\u0258"+ - "\u0253\3\2\2\2\u0259\u025c\3\2\2\2\u025a\u0258\3\2\2\2\u025a\u025b\3\2"+ - "\2\2\u025bm\3\2\2\2\u025c\u025a\3\2\2\2\u025d\u025e\5\32\16\2\u025e\u0262"+ - "\7D\2\2\u025f\u0263\5B\"\2\u0260\u0263\5D#\2\u0261\u0263\7]\2\2\u0262"+ - "\u025f\3\2\2\2\u0262\u0260\3\2\2\2\u0262\u0261\3\2\2\2\u0263o\3\2\2\2"+ - "\u0264\u0265\7^\2\2\u0265\u0267\5(\25\2\u0266\u0268\7t\2\2\u0267\u0266"+ - "\3\2\2\2\u0267\u0268\3\2\2\2\u0268\u026b\3\2\2\2\u0269\u026c\5\b\5\2\u026a"+ - "\u026c\5\\/\2\u026b\u0269\3\2\2\2\u026b\u026a\3\2\2\2\u026c\u026e\3\2"+ - "\2\2\u026d\u026f\7t\2\2\u026e\u026d\3\2\2\2\u026e\u026f\3\2\2\2\u026f"+ - "\u0271\3\2\2\2\u0270\u0272\5r:\2\u0271\u0270\3\2\2\2\u0271\u0272\3\2\2"+ - "\2\u0272q\3\2\2\2\u0273\u0275\7_\2\2\u0274\u0276\7t\2\2\u0275\u0274\3"+ - "\2\2\2\u0275\u0276\3\2\2\2\u0276\u0279\3\2\2\2\u0277\u027a\5\b\5\2\u0278"+ - "\u027a\5\\/\2\u0279\u0277\3\2\2\2\u0279\u0278\3\2\2\2\u027as\3\2\2\2\u027b"+ - "\u027d\5v<\2\u027c\u027e\7t\2\2\u027d\u027c\3\2\2\2\u027d\u027e\3\2\2"+ - "\2\u027e\u0281\3\2\2\2\u027f\u0282\5\b\5\2\u0280\u0282\5\\/\2\u0281\u027f"+ - "\3\2\2\2\u0281\u0280\3\2\2\2\u0282\u0284\3\2\2\2\u0283\u0285\7t\2\2\u0284"+ - "\u0283\3\2\2\2\u0284\u0285\3\2\2\2\u0285\u0287\3\2\2\2\u0286\u0288\5r"+ - ":\2\u0287\u0286\3\2\2\2\u0287\u0288\3\2\2\2\u0288\u0289\3\2\2\2\u0289"+ - "\u028a\7t\2\2\u028au\3\2\2\2\u028b\u028c\t\21\2\2\u028cw\3\2\2\2\u028d"+ - "\u028f\7l\2\2\u028e\u0290\5\32\16\2\u028f\u028e\3\2\2\2\u028f\u0290\3"+ - "\2\2\2\u0290\u0292\3\2\2\2\u0291\u0293\7}\2\2\u0292\u0291\3\2\2\2\u0292"+ - "\u0293\3\2\2\2\u0293\u0296\3\2\2\2\u0294\u0297\5@!\2\u0295\u0297\5<\37"+ - "\2\u0296\u0294\3\2\2\2\u0296\u0295\3\2\2\2\u0297\u0298\3\2\2\2\u0298\u0299"+ - "\7m\2\2\u0299\u029b\5(\25\2\u029a\u029c\7t\2\2\u029b\u029a\3\2\2\2\u029b"+ - "\u029c\3\2\2\2\u029c\u029f\3\2\2\2\u029d\u02a0\5\b\5\2\u029e\u02a0\5\\"+ - "/\2\u029f\u029d\3\2\2\2\u029f\u029e\3\2\2\2\u02a0y\3\2\2\2\u02a1\u02a2"+ - "\7n\2\2\u02a2\u02a4\5(\25\2\u02a3\u02a5\7t\2\2\u02a4\u02a3\3\2\2\2\u02a4"+ - "\u02a5\3\2\2\2\u02a5\u02a8\3\2\2\2\u02a6\u02a9\5\b\5\2\u02a7\u02a9\5\\"+ - "/\2\u02a8\u02a6\3\2\2\2\u02a8\u02a7\3\2\2\2\u02a9{\3\2\2\2\u02aa\u02ad"+ - "\7o\2\2\u02ab\u02ae\5\b\5\2\u02ac\u02ae\5\\/\2\u02ad\u02ab\3\2\2\2\u02ad"+ - "\u02ac\3\2\2\2\u02ae\u02b0\3\2\2\2\u02af\u02b1\7t\2\2\u02b0\u02af\3\2"+ - "\2\2\u02b0\u02b1\3\2\2\2\u02b1\u02b2\3\2\2\2\u02b2\u02b3\7p\2\2\u02b3"+ - "\u02b4\5(\25\2\u02b4}\3\2\2\2^\u0080\u0082\u0089\u008e\u00a9\u00b1\u00b5"+ - "\u00bc\u00bf\u00c4\u00c8\u00cb\u00e8\u00f3\u0107\u010b\u010f\u0114\u0118"+ - "\u011d\u0121\u0126\u012a\u012f\u0133\u0138\u013c\u0141\u0145\u014a\u014e"+ - "\u0153\u0157\u015c\u0160\u0165\u0169\u016e\u0172\u017a\u017e\u0180\u0191"+ - "\u0198\u019f\u01a4\u01a9\u01b6\u01c1\u01c9\u01ce\u01d3\u01d7\u01e7\u01f0"+ - "\u01f4\u0200\u0202\u020a\u020f\u0215\u021a\u0221\u0228\u022e\u0233\u023b"+ - "\u0240\u0248\u024f\u0255\u025a\u0262\u0267\u026b\u026e\u0271\u0275\u0279"+ - "\u027d\u0281\u0284\u0287\u028f\u0292\u0296\u029b\u029f\u02a4\u02a8\u02ad"+ - "\u02b0"; + "\3\2\2\2\u0230\u0231\7B\2\2\u0231\u0232\7X\2\2\u0232\u0234\7A\2\2\u0233"+ + "\u0235\5n8\2\u0234\u0233\3\2\2\2\u0234\u0235\3\2\2\2\u0235\u0236\3\2\2"+ + "\2\u0236\u0239\7B\2\2\u0237\u023a\5f\64\2\u0238\u023a\5^\60\2\u0239\u0237"+ + "\3\2\2\2\u0239\u0238\3\2\2\2\u023ae\3\2\2\2\u023b\u023c\7\21\2\2\u023c"+ + "\u023d\5H%\2\u023dg\3\2\2\2\u023e\u0246\5j\66\2\u023f\u0241\7\20\2\2\u0240"+ + "\u0242\7t\2\2\u0241\u0240\3\2\2\2\u0241\u0242\3\2\2\2\u0242\u0243\3\2"+ + "\2\2\u0243\u0245\5j\66\2\u0244\u023f\3\2\2\2\u0245\u0248\3\2\2\2\u0246"+ + "\u0244\3\2\2\2\u0246\u0247\3\2\2\2\u0247i\3\2\2\2\u0248\u0246\3\2\2\2"+ + "\u0249\u024a\5\22\n\2\u024a\u024e\7D\2\2\u024b\u024f\5D#\2\u024c\u024f"+ + "\5F$\2\u024d\u024f\7]\2\2\u024e\u024b\3\2\2\2\u024e\u024c\3\2\2\2\u024e"+ + "\u024d\3\2\2\2\u024fk\3\2\2\2\u0250\u0255\5B\"\2\u0251\u0252\7\20\2\2"+ + "\u0252\u0254\5B\"\2\u0253\u0251\3\2\2\2\u0254\u0257\3\2\2\2\u0255\u0253"+ + "\3\2\2\2\u0255\u0256\3\2\2\2\u0256m\3\2\2\2\u0257\u0255\3\2\2\2\u0258"+ + "\u0260\5p9\2\u0259\u025b\7\20\2\2\u025a\u025c\7t\2\2\u025b\u025a\3\2\2"+ + "\2\u025b\u025c\3\2\2\2\u025c\u025d\3\2\2\2\u025d\u025f\5p9\2\u025e\u0259"+ + "\3\2\2\2\u025f\u0262\3\2\2\2\u0260\u025e\3\2\2\2\u0260\u0261\3\2\2\2\u0261"+ + "o\3\2\2\2\u0262\u0260\3\2\2\2\u0263\u0264\5\32\16\2\u0264\u0268\7D\2\2"+ + "\u0265\u0269\5D#\2\u0266\u0269\5F$\2\u0267\u0269\7]\2\2\u0268\u0265\3"+ + "\2\2\2\u0268\u0266\3\2\2\2\u0268\u0267\3\2\2\2\u0269q\3\2\2\2\u026a\u026b"+ + "\7^\2\2\u026b\u026d\5(\25\2\u026c\u026e\7t\2\2\u026d\u026c\3\2\2\2\u026d"+ + "\u026e\3\2\2\2\u026e\u0271\3\2\2\2\u026f\u0272\5\b\5\2\u0270\u0272\5^"+ + "\60\2\u0271\u026f\3\2\2\2\u0271\u0270\3\2\2\2\u0272\u0274\3\2\2\2\u0273"+ + "\u0275\7t\2\2\u0274\u0273\3\2\2\2\u0274\u0275\3\2\2\2\u0275\u0277\3\2"+ + "\2\2\u0276\u0278\5t;\2\u0277\u0276\3\2\2\2\u0277\u0278\3\2\2\2\u0278s"+ + "\3\2\2\2\u0279\u027b\7_\2\2\u027a\u027c\7t\2\2\u027b\u027a\3\2\2\2\u027b"+ + "\u027c\3\2\2\2\u027c\u027f\3\2\2\2\u027d\u0280\5\b\5\2\u027e\u0280\5^"+ + "\60\2\u027f\u027d\3\2\2\2\u027f\u027e\3\2\2\2\u0280u\3\2\2\2\u0281\u0283"+ + "\5x=\2\u0282\u0284\7t\2\2\u0283\u0282\3\2\2\2\u0283\u0284\3\2\2\2\u0284"+ + "\u0287\3\2\2\2\u0285\u0288\5\b\5\2\u0286\u0288\5^\60\2\u0287\u0285\3\2"+ + "\2\2\u0287\u0286\3\2\2\2\u0288\u028a\3\2\2\2\u0289\u028b\7t\2\2\u028a"+ + "\u0289\3\2\2\2\u028a\u028b\3\2\2\2\u028b\u028d\3\2\2\2\u028c\u028e\5t"+ + ";\2\u028d\u028c\3\2\2\2\u028d\u028e\3\2\2\2\u028e\u028f\3\2\2\2\u028f"+ + "\u0290\7t\2\2\u0290w\3\2\2\2\u0291\u0292\t\21\2\2\u0292y\3\2\2\2\u0293"+ + "\u0295\7l\2\2\u0294\u0296\5\32\16\2\u0295\u0294\3\2\2\2\u0295\u0296\3"+ + "\2\2\2\u0296\u0298\3\2\2\2\u0297\u0299\7}\2\2\u0298\u0297\3\2\2\2\u0298"+ + "\u0299\3\2\2\2\u0299\u029c\3\2\2\2\u029a\u029d\5B\"\2\u029b\u029d\5> "+ + "\2\u029c\u029a\3\2\2\2\u029c\u029b\3\2\2\2\u029d\u029e\3\2\2\2\u029e\u029f"+ + "\7m\2\2\u029f\u02a1\5(\25\2\u02a0\u02a2\7t\2\2\u02a1\u02a0\3\2\2\2\u02a1"+ + "\u02a2\3\2\2\2\u02a2\u02a5\3\2\2\2\u02a3\u02a6\5\b\5\2\u02a4\u02a6\5^"+ + "\60\2\u02a5\u02a3\3\2\2\2\u02a5\u02a4\3\2\2\2\u02a6{\3\2\2\2\u02a7\u02a8"+ + "\7n\2\2\u02a8\u02aa\5(\25\2\u02a9\u02ab\7t\2\2\u02aa\u02a9\3\2\2\2\u02aa"+ + "\u02ab\3\2\2\2\u02ab\u02ae\3\2\2\2\u02ac\u02af\5\b\5\2\u02ad\u02af\5^"+ + "\60\2\u02ae\u02ac\3\2\2\2\u02ae\u02ad\3\2\2\2\u02af}\3\2\2\2\u02b0\u02b3"+ + "\7o\2\2\u02b1\u02b4\5\b\5\2\u02b2\u02b4\5^\60\2\u02b3\u02b1\3\2\2\2\u02b3"+ + "\u02b2\3\2\2\2\u02b4\u02b6\3\2\2\2\u02b5\u02b7\7t\2\2\u02b6\u02b5\3\2"+ + "\2\2\u02b6\u02b7\3\2\2\2\u02b7\u02b8\3\2\2\2\u02b8\u02b9\7p\2\2\u02b9"+ + "\u02ba\5(\25\2\u02ba\177\3\2\2\2^\u0082\u0084\u008b\u0090\u00ab\u00b3"+ + "\u00b7\u00be\u00c1\u00c6\u00ca\u00cd\u00ea\u00f5\u010a\u010e\u0112\u0117"+ + "\u011b\u0120\u0124\u0129\u012d\u0132\u0136\u013b\u013f\u0144\u0148\u014d"+ + "\u0151\u0156\u015a\u015f\u0163\u0168\u016c\u0171\u0175\u017d\u0181\u0183"+ + "\u0197\u019e\u01a5\u01aa\u01af\u01bc\u01c7\u01cf\u01d4\u01d9\u01dd\u01ed"+ + "\u01f6\u01fa\u0206\u0208\u0210\u0215\u021b\u0220\u0227\u022e\u0234\u0239"+ + "\u0241\u0246\u024e\u0255\u025b\u0260\u0268\u026d\u0271\u0274\u0277\u027b"+ + "\u027f\u0283\u0287\u028a\u028d\u0295\u0298\u029c\u02a1\u02a5\u02aa\u02ae"+ + "\u02b3\u02b6"; public static final ATN _ATN = new ATNDeserializer().deserialize(_serializedATN.toCharArray()); static {