Apple-2-SW/prog8
1
0
Fork 0
mirror of https://github.com/irmen/prog8.git synced 2024-11-29 17:50:35 +00:00
Code Issues Projects Releases Wiki Activity

got rid of separate str_s datatype

Browse Source
This commit is contained in:
Irmen de Jong 2020-02-07 20:47:38 +01:00
parent a01a9e76f9
commit b8816a0e2f
26 changed files with 721 additions and 743 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
.idea/misc.xml generated
View File

@ -1,5 +1,21 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project version="4"> <project version="4">
<component name="ANTLRGenerationPreferences">
<option name="perGrammarGenerationSettings">
<list>
<PerGrammarGenerationSettings>
<option name="fileName" value="$PROJECT_DIR$/parser/antlr/prog8.g4" />
<option name="autoGen" value="true" />
<option name="outputDir" value="$PROJECT_DIR$/parser/src/prog8/parser" />
<option name="libDir" value="" />
<option name="encoding" value="" />
<option name="pkg" value="" />
<option name="language" value="" />
<option name="generateListener" value="false" />
</PerGrammarGenerationSettings>
</list>
</option>
</component>
<component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK"> <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="false" project-jdk-name="Kotlin SDK" project-jdk-type="KotlinSDK">
<output url="file://$PROJECT_DIR$/out" /> <output url="file://$PROJECT_DIR$/out" />
</component> </component>

3
compiler/src/prog8/ast/AstToSourceCode.kt
View File

@ -3,7 +3,6 @@ package prog8.ast
import prog8.ast.antlr.escape import prog8.ast.antlr.escape
import prog8.ast.base.DataType import prog8.ast.base.DataType
import prog8.ast.base.NumericDatatypes import prog8.ast.base.NumericDatatypes
import prog8.ast.base.StringDatatypes
import prog8.ast.base.VarDeclType import prog8.ast.base.VarDeclType
import prog8.ast.expressions.* import prog8.ast.expressions.*
import prog8.ast.processing.IAstVisitor import prog8.ast.processing.IAstVisitor
@ -79,7 +78,7 @@ class AstToSourceCode(val output: (text: String) -> Unit, val program: Program):
private fun datatypeString(dt: DataType): String { private fun datatypeString(dt: DataType): String {
return when(dt) { return when(dt) {
in NumericDatatypes -> dt.toString().toLowerCase() in NumericDatatypes -> dt.toString().toLowerCase()
in StringDatatypes -> dt.toString().toLowerCase() DataType.STR -> dt.toString().toLowerCase()
DataType.ARRAY_UB -> "ubyte[" DataType.ARRAY_UB -> "ubyte["
DataType.ARRAY_B -> "byte[" DataType.ARRAY_B -> "byte["
DataType.ARRAY_UW -> "uword[" DataType.ARRAY_UW -> "uword["

8
compiler/src/prog8/ast/base/Base.kt
View File

@ -13,7 +13,6 @@ enum class DataType {
WORD, // pass by value WORD, // pass by value
FLOAT, // pass by value FLOAT, // pass by value
STR, // pass by reference STR, // pass by reference
STR_S, // pass by reference
ARRAY_UB, // pass by reference ARRAY_UB, // pass by reference
ARRAY_B, // pass by reference ARRAY_B, // pass by reference
ARRAY_UW, // pass by reference ARRAY_UW, // pass by reference
@ -32,8 +31,7 @@ enum class DataType {
UWORD -> targetType in setOf(UWORD, FLOAT) UWORD -> targetType in setOf(UWORD, FLOAT)
WORD -> targetType in setOf(WORD, FLOAT) WORD -> targetType in setOf(WORD, FLOAT)
FLOAT -> targetType == FLOAT FLOAT -> targetType == FLOAT
STR -> targetType == STR || targetType==STR_S STR -> targetType == STR
STR_S -> targetType == STR || targetType==STR_S
in ArrayDatatypes -> targetType == this in ArrayDatatypes -> targetType == this
else -> false else -> false
} }
@ -113,10 +111,9 @@ val ByteDatatypes = setOf(DataType.UBYTE, DataType.BYTE)
val WordDatatypes = setOf(DataType.UWORD, DataType.WORD) val WordDatatypes = setOf(DataType.UWORD, DataType.WORD)
val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD) val IntegerDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD)
val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT) val NumericDatatypes = setOf(DataType.UBYTE, DataType.BYTE, DataType.UWORD, DataType.WORD, DataType.FLOAT)
val StringDatatypes = setOf(DataType.STR, DataType.STR_S)
val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F) val ArrayDatatypes = setOf(DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_F)
val IterableDatatypes = setOf( val IterableDatatypes = setOf(
DataType.STR, DataType.STR_S, DataType.STR,
DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UB, DataType.ARRAY_B,
DataType.ARRAY_UW, DataType.ARRAY_W, DataType.ARRAY_UW, DataType.ARRAY_W,
DataType.ARRAY_F) DataType.ARRAY_F)
@ -124,7 +121,6 @@ val PassByValueDatatypes = NumericDatatypes
val PassByReferenceDatatypes = IterableDatatypes.plus(DataType.STRUCT) val PassByReferenceDatatypes = IterableDatatypes.plus(DataType.STRUCT)
val ArrayElementTypes = mapOf( val ArrayElementTypes = mapOf(
DataType.STR to DataType.UBYTE, DataType.STR to DataType.UBYTE,
DataType.STR_S to DataType.UBYTE,
DataType.ARRAY_B to DataType.BYTE, DataType.ARRAY_B to DataType.BYTE,
DataType.ARRAY_UB to DataType.UBYTE, DataType.ARRAY_UB to DataType.UBYTE,
DataType.ARRAY_W to DataType.WORD, DataType.ARRAY_W to DataType.WORD,

3
compiler/src/prog8/ast/expressions/AstExpressions.kt
View File

@ -197,7 +197,7 @@ class ArrayIndexedExpression(var identifier: IdentifierReference,
val target = identifier.targetStatement(program.namespace) val target = identifier.targetStatement(program.namespace)
if (target is VarDecl) { if (target is VarDecl) {
return when (target.datatype) { return when (target.datatype) {
in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE) DataType.STR -> InferredTypes.knownFor(DataType.UBYTE)
in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(target.datatype)) in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(target.datatype))
else -> InferredTypes.unknown() else -> InferredTypes.unknown()
} }
@ -524,7 +524,6 @@ class RangeExpr(var from: Expression,
fromDt istype DataType.UBYTE && toDt istype DataType.UBYTE -> InferredTypes.knownFor(DataType.ARRAY_UB) fromDt istype DataType.UBYTE && toDt istype DataType.UBYTE -> InferredTypes.knownFor(DataType.ARRAY_UB)
fromDt istype DataType.UWORD && toDt istype DataType.UWORD -> InferredTypes.knownFor(DataType.ARRAY_UW) fromDt istype DataType.UWORD && toDt istype DataType.UWORD -> InferredTypes.knownFor(DataType.ARRAY_UW)
fromDt istype DataType.STR && toDt istype DataType.STR -> InferredTypes.knownFor(DataType.STR) fromDt istype DataType.STR && toDt istype DataType.STR -> InferredTypes.knownFor(DataType.STR)
fromDt istype DataType.STR_S && toDt istype DataType.STR_S -> InferredTypes.knownFor(DataType.STR_S)
fromDt istype DataType.WORD || toDt istype DataType.WORD -> InferredTypes.knownFor(DataType.ARRAY_W) fromDt istype DataType.WORD || toDt istype DataType.WORD -> InferredTypes.knownFor(DataType.ARRAY_W)
fromDt istype DataType.BYTE || toDt istype DataType.BYTE -> InferredTypes.knownFor(DataType.ARRAY_B) fromDt istype DataType.BYTE || toDt istype DataType.BYTE -> InferredTypes.knownFor(DataType.ARRAY_B)
else -> InferredTypes.knownFor(DataType.ARRAY_UB) else -> InferredTypes.knownFor(DataType.ARRAY_UB)

1
compiler/src/prog8/ast/expressions/InferredTypes.kt
View File

@ -46,7 +46,6 @@ object InferredTypes {
DataType.WORD to InferredType.known(DataType.WORD), DataType.WORD to InferredType.known(DataType.WORD),
DataType.FLOAT to InferredType.known(DataType.FLOAT), DataType.FLOAT to InferredType.known(DataType.FLOAT),
DataType.STR to InferredType.known(DataType.STR), DataType.STR to InferredType.known(DataType.STR),
DataType.STR_S to InferredType.known(DataType.STR_S),
DataType.ARRAY_UB to InferredType.known(DataType.ARRAY_UB), DataType.ARRAY_UB to InferredType.known(DataType.ARRAY_UB),
DataType.ARRAY_B to InferredType.known(DataType.ARRAY_B), DataType.ARRAY_B to InferredType.known(DataType.ARRAY_B),
DataType.ARRAY_UW to InferredType.known(DataType.ARRAY_UW), DataType.ARRAY_UW to InferredType.known(DataType.ARRAY_UW),

45
compiler/src/prog8/ast/processing/AstChecker.kt
View File

@ -1,5 +1,3 @@
@file:Suppress("DuplicatedCode")
package prog8.ast.processing package prog8.ast.processing
import prog8.ast.IFunctionCall import prog8.ast.IFunctionCall
@ -125,7 +123,7 @@ internal class AstChecker(private val program: Program,
} else { } else {
if (forLoop.loopRegister != null) { if (forLoop.loopRegister != null) {
// loop register // loop register
if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt !in StringDatatypes) if (iterableDt != DataType.ARRAY_UB && iterableDt != DataType.ARRAY_B && iterableDt != DataType.STR)
checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position)) checkResult.add(ExpressionError("register can only loop over bytes", forLoop.position))
if(forLoop.loopRegister!=Register.A) if(forLoop.loopRegister!=Register.A)
checkResult.add(ExpressionError("it's only possible to use A as a loop register", forLoop.position)) checkResult.add(ExpressionError("it's only possible to use A as a loop register", forLoop.position))
@ -137,11 +135,11 @@ internal class AstChecker(private val program: Program,
} else { } else {
when (loopvar.datatype) { when (loopvar.datatype) {
DataType.UBYTE -> { DataType.UBYTE -> {
if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt !in StringDatatypes) if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.ARRAY_UB && iterableDt != DataType.STR)
checkResult.add(ExpressionError("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position)) checkResult.add(ExpressionError("ubyte loop variable can only loop over unsigned bytes or strings", forLoop.position))
} }
DataType.UWORD -> { DataType.UWORD -> {
if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt !in StringDatatypes && if(iterableDt!= DataType.UBYTE && iterableDt!= DataType.UWORD && iterableDt != DataType.STR &&
iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW) iterableDt != DataType.ARRAY_UB && iterableDt!= DataType.ARRAY_UW)
checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position)) checkResult.add(ExpressionError("uword loop variable can only loop over unsigned bytes, words or strings", forLoop.position))
} }
@ -245,7 +243,7 @@ internal class AstChecker(private val program: Program,
} }
else if(param.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) { else if(param.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
if (param.first.type != DataType.UWORD && param.first.type != DataType.WORD if (param.first.type != DataType.UWORD && param.first.type != DataType.WORD
&& param.first.type !in StringDatatypes && param.first.type !in ArrayDatatypes && param.first.type != DataType.FLOAT) && param.first.type != DataType.STR && param.first.type !in ArrayDatatypes && param.first.type != DataType.FLOAT)
err("parameter '${param.first.name}' should be (u)word/address") err("parameter '${param.first.name}' should be (u)word/address")
} }
else if(param.second.statusflag!=null) { else if(param.second.statusflag!=null) {
@ -260,7 +258,7 @@ internal class AstChecker(private val program: Program,
} }
else if(ret.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) { else if(ret.second.registerOrPair in setOf(RegisterOrPair.AX, RegisterOrPair.AY, RegisterOrPair.XY)) {
if (ret.first.value != DataType.UWORD && ret.first.value != DataType.WORD if (ret.first.value != DataType.UWORD && ret.first.value != DataType.WORD
&& ret.first.value !in StringDatatypes && ret.first.value !in ArrayDatatypes && ret.first.value != DataType.FLOAT) && ret.first.value != DataType.STR && ret.first.value !in ArrayDatatypes && ret.first.value != DataType.FLOAT)
err("return value #${ret.first.index + 1} should be (u)word/address") err("return value #${ret.first.index + 1} should be (u)word/address")
} }
else if(ret.second.statusflag!=null) { else if(ret.second.statusflag!=null) {
@ -411,7 +409,7 @@ internal class AstChecker(private val program: Program,
} }
} }
val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR) val targetDt = assignTarget.inferType(program, assignment).typeOrElse(DataType.STR)
if(targetDt in StringDatatypes || targetDt in ArrayDatatypes) if(targetDt in IterableDatatypes)
checkResult.add(SyntaxError("cannot assign to a string or array type", assignTarget.position)) checkResult.add(SyntaxError("cannot assign to a string or array type", assignTarget.position))
if (assignment is Assignment) { if (assignment is Assignment) {
@ -447,7 +445,7 @@ internal class AstChecker(private val program: Program,
if(variable==null) if(variable==null)
checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", addressOf.position)) checkResult.add(ExpressionError("pointer-of operand must be the name of a heap variable", addressOf.position))
else { else {
if(variable.datatype !in ArrayDatatypes && variable.datatype !in StringDatatypes && variable.datatype!=DataType.STRUCT) if(variable.datatype !in ArrayDatatypes && variable.datatype != DataType.STR && variable.datatype!=DataType.STRUCT)
checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position)) checkResult.add(ExpressionError("invalid pointer-of operand type", addressOf.position))
} }
super.visit(addressOf) super.visit(addressOf)
@ -876,10 +874,10 @@ internal class AstChecker(private val program: Program,
checkResult.add(ExpressionError("swap requires args of numerical type", position)) checkResult.add(ExpressionError("swap requires args of numerical type", position))
} }
else if(target.name=="all" || target.name=="any") { else if(target.name=="all" || target.name=="any") {
if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype in StringDatatypes) { if((args[0] as? AddressOf)?.identifier?.targetVarDecl(program.namespace)?.datatype == DataType.STR) {
checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position)) checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
} }
if(args[0].inferType(program).typeOrElse(DataType.STR) in StringDatatypes) { if(args[0].inferType(program).typeOrElse(DataType.STR) == DataType.STR) {
checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position)) checkResult.add(ExpressionError("any/all on a string is useless (is always true unless the string is empty)", position))
} }
} }
@ -896,7 +894,7 @@ internal class AstChecker(private val program: Program,
val argDt=argIDt.typeOrElse(DataType.STRUCT) val argDt=argIDt.typeOrElse(DataType.STRUCT)
if(!(argDt isAssignableTo arg.second.type)) { if(!(argDt isAssignableTo arg.second.type)) {
// for asm subroutines having STR param it's okay to provide a UWORD (address value) // for asm subroutines having STR param it's okay to provide a UWORD (address value)
if(!(target.isAsmSubroutine && arg.second.type in StringDatatypes && argDt == DataType.UWORD)) if(!(target.isAsmSubroutine && arg.second.type == DataType.STR && argDt == DataType.UWORD))
checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position)) checkResult.add(ExpressionError("subroutine '${target.name}' argument ${arg.first.index + 1} has invalid type $argDt, expected ${arg.second.type}", position))
} }
@ -963,7 +961,7 @@ internal class AstChecker(private val program: Program,
val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt() val index = (arrayIndexedExpression.arrayspec.index as? NumericLiteralValue)?.number?.toInt()
if(index!=null && (index<0 || index>=arraysize)) if(index!=null && (index<0 || index>=arraysize))
checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position)) checkResult.add(ExpressionError("array index out of bounds", arrayIndexedExpression.arrayspec.position))
} else if(target.datatype in StringDatatypes) { } else if(target.datatype == DataType.STR) {
if(target.value is StringLiteralValue) { if(target.value is StringLiteralValue) {
// check string lengths for non-memory mapped strings // check string lengths for non-memory mapped strings
val stringLen = (target.value as StringLiteralValue).value.length val stringLen = (target.value as StringLiteralValue).value.length
@ -1047,19 +1045,15 @@ internal class AstChecker(private val program: Program,
} }
private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteralValue) : Boolean { private fun checkValueTypeAndRangeString(targetDt: DataType, value: StringLiteralValue) : Boolean {
fun err(msg: String): Boolean { return if (targetDt == DataType.STR) {
checkResult.add(ExpressionError(msg, value.position)) if (value.value.length > 255) {
return false checkResult.add(ExpressionError("string length must be 0-255", value.position))
} false
return when (targetDt) {
in StringDatatypes -> {
return if (value.value.length > 255)
err("string length must be 0-255")
else
true
} }
else -> false else
true
} }
else false
} }
private fun checkValueTypeAndRangeArray(targetDt: DataType, struct: StructDecl?, private fun checkValueTypeAndRangeArray(targetDt: DataType, struct: StructDecl?,
@ -1069,7 +1063,7 @@ internal class AstChecker(private val program: Program,
return false return false
} }
when (targetDt) { when (targetDt) {
in StringDatatypes -> return err("string value expected") DataType.STR -> return err("string value expected")
DataType.ARRAY_UB, DataType.ARRAY_B -> { DataType.ARRAY_UB, DataType.ARRAY_B -> {
// value may be either a single byte, or a byte arraysize (of all constant values), or a range // value may be either a single byte, or a byte arraysize (of all constant values), or a range
if(value.type==targetDt) { if(value.type==targetDt) {
@ -1276,7 +1270,6 @@ internal class AstChecker(private val program: Program,
DataType.UWORD -> sourceDatatype== DataType.UBYTE || sourceDatatype== DataType.UWORD DataType.UWORD -> sourceDatatype== DataType.UBYTE || sourceDatatype== DataType.UWORD
DataType.FLOAT -> sourceDatatype in NumericDatatypes DataType.FLOAT -> sourceDatatype in NumericDatatypes
DataType.STR -> sourceDatatype== DataType.STR DataType.STR -> sourceDatatype== DataType.STR
DataType.STR_S -> sourceDatatype== DataType.STR_S
DataType.STRUCT -> { DataType.STRUCT -> {
if(sourceDatatype==DataType.STRUCT) { if(sourceDatatype==DataType.STRUCT) {
val structLv = sourceValue as StructLiteralValue val structLv = sourceValue as StructLiteralValue

4
compiler/src/prog8/ast/processing/VarInitValueAndAddressOfCreator.kt
View File

@ -103,14 +103,14 @@ internal class VarInitValueAndAddressOfCreator(private val program: Program): IA
private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<Expression>, parent: Statement) { private fun addAddressOfExprIfNeeded(subroutine: Subroutine, arglist: MutableList<Expression>, parent: Statement) {
// functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead. // functions that accept UWORD and are given an array type, or string, will receive the AddressOf (memory location) of that value instead.
for(argparam in subroutine.parameters.withIndex().zip(arglist)) { for(argparam in subroutine.parameters.withIndex().zip(arglist)) {
if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type in StringDatatypes) { if(argparam.first.value.type==DataType.UWORD || argparam.first.value.type == DataType.STR) {
if(argparam.second is AddressOf) if(argparam.second is AddressOf)
continue continue
val idref = argparam.second as? IdentifierReference val idref = argparam.second as? IdentifierReference
val strvalue = argparam.second as? StringLiteralValue val strvalue = argparam.second as? StringLiteralValue
if(idref!=null) { if(idref!=null) {
val variable = idref.targetVarDecl(program.namespace) val variable = idref.targetVarDecl(program.namespace)
if(variable!=null && (variable.datatype in StringDatatypes || variable.datatype in ArrayDatatypes)) { if(variable!=null && variable.datatype in IterableDatatypes) {
val pointerExpr = AddressOf(idref, idref.position) val pointerExpr = AddressOf(idref, idref.position)
pointerExpr.linkParents(arglist[argparam.first.index].parent) pointerExpr.linkParents(arglist[argparam.first.index].parent)
arglist[argparam.first.index] = pointerExpr arglist[argparam.first.index] = pointerExpr

28
compiler/src/prog8/compiler/target/c64/codegen/AsmGen.kt
View File

@ -206,18 +206,9 @@ internal class AsmGen(private val program: Program,
return "$b0, $b1, $b2, $b3, $b4" return "$b0, $b1, $b2, $b3, $b4"
} }
private fun encodeStr(str: String, dt: DataType): List<Short> { private fun encodeStr(str: String): List<Short> {
return when(dt) { val bytes = Petscii.encodePetscii(str, true)
DataType.STR -> { return bytes.plus(0)
val bytes = Petscii.encodePetscii(str, true)
bytes.plus(0)
}
DataType.STR_S -> {
val bytes = Petscii.encodeScreencode(str, true)
bytes.plus(0)
}
else -> throw AssemblyError("invalid str type")
}
} }
private fun zeropagevars2asm(statements: List<Statement>) { private fun zeropagevars2asm(statements: List<Statement>) {
@ -254,10 +245,9 @@ internal class AsmGen(private val program: Program,
DataType.WORD -> out("${decl.name}\t.sint 0") DataType.WORD -> out("${decl.name}\t.sint 0")
DataType.FLOAT -> out("${decl.name}\t.byte 0,0,0,0,0 ; float") DataType.FLOAT -> out("${decl.name}\t.byte 0,0,0,0,0 ; float")
DataType.STRUCT -> {} // is flattened DataType.STRUCT -> {} // is flattened
DataType.STR, DataType.STR_S -> { DataType.STR -> {
val string = (decl.value as StringLiteralValue).value val string = (decl.value as StringLiteralValue).value
val encoded = encodeStr(string, decl.datatype) outputStringvar(decl, encodeStr(string))
outputStringvar(decl, encoded)
} }
DataType.ARRAY_UB -> { DataType.ARRAY_UB -> {
val data = makeArrayFillDataUnsigned(decl) val data = makeArrayFillDataUnsigned(decl)
@ -340,8 +330,8 @@ internal class AsmGen(private val program: Program,
// special treatment for string types: merge strings that are identical // special treatment for string types: merge strings that are identical
val encodedstringVars = normalVars val encodedstringVars = normalVars
.filter {it.datatype in StringDatatypes } .filter {it.datatype == DataType.STR }
.map { it to encodeStr((it.value as StringLiteralValue).value, it.datatype) } .map { it to encodeStr((it.value as StringLiteralValue).value) }
.groupBy({it.second}, {it.first}) .groupBy({it.second}, {it.first})
for((encoded, variables) in encodedstringVars) { for((encoded, variables) in encodedstringVars) {
variables.dropLast(1).forEach { out(it.name) } variables.dropLast(1).forEach { out(it.name) }
@ -350,7 +340,7 @@ internal class AsmGen(private val program: Program,
} }
// non-string variables // non-string variables
normalVars.filter{ it.datatype !in StringDatatypes}.sortedBy { it.datatype }.forEach { normalVars.filter{ it.datatype != DataType.STR }.sortedBy { it.datatype }.forEach {
if(it.scopedname !in allocatedZeropageVariables) if(it.scopedname !in allocatedZeropageVariables)
vardecl2asm(it) vardecl2asm(it)
} }
@ -510,7 +500,7 @@ internal class AsmGen(private val program: Program,
internal fun readAndPushArrayvalueWithIndexA(arrayDt: DataType, variable: IdentifierReference) { internal fun readAndPushArrayvalueWithIndexA(arrayDt: DataType, variable: IdentifierReference) {
val variablename = asmIdentifierName(variable) val variablename = asmIdentifierName(variable)
when (arrayDt) { when (arrayDt) {
DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B -> DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
out(" tay | lda $variablename,y | sta $ESTACK_LO_HEX,x | dex") out(" tay | lda $variablename,y | sta $ESTACK_LO_HEX,x | dex")
DataType.ARRAY_UW, DataType.ARRAY_W -> DataType.ARRAY_UW, DataType.ARRAY_W ->
out(" asl a | tay | lda $variablename,y | sta $ESTACK_LO_HEX,x | lda $variablename+1,y | sta $ESTACK_HI_HEX,x | dex") out(" asl a | tay | lda $variablename,y | sta $ESTACK_LO_HEX,x | lda $variablename+1,y | sta $ESTACK_HI_HEX,x | dex")

4
compiler/src/prog8/compiler/target/c64/codegen/AssignmentAsmGen.kt
View File

@ -83,7 +83,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier) val arrayVarName = asmgen.asmIdentifierName(arrayExpr.identifier)
val indexValue = index.number.toInt() * ArrayElementTypes.getValue(arrayDt).memorySize() val indexValue = index.number.toInt() * ArrayElementTypes.getValue(arrayDt).memorySize()
when (arrayDt) { when (arrayDt) {
DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B -> DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
asmgen.out(" lda $arrayVarName+$indexValue | sta $ESTACK_LO_HEX,x | dex") asmgen.out(" lda $arrayVarName+$indexValue | sta $ESTACK_LO_HEX,x | dex")
DataType.ARRAY_UW, DataType.ARRAY_W -> DataType.ARRAY_UW, DataType.ARRAY_W ->
asmgen.out(" lda $arrayVarName+$indexValue | sta $ESTACK_LO_HEX,x | lda $arrayVarName+$indexValue+1 | sta $ESTACK_HI_HEX,x | dex") asmgen.out(" lda $arrayVarName+$indexValue | sta $ESTACK_LO_HEX,x | lda $arrayVarName+$indexValue+1 | sta $ESTACK_HI_HEX,x | dex")
@ -730,7 +730,7 @@ internal class AssignmentAsmGen(private val program: Program, private val asmgen
private fun popAndWriteArrayvalueWithIndexA(arrayDt: DataType, variablename: String) { private fun popAndWriteArrayvalueWithIndexA(arrayDt: DataType, variablename: String) {
when (arrayDt) { when (arrayDt) {
DataType.STR, DataType.STR_S, DataType.ARRAY_UB, DataType.ARRAY_B -> DataType.STR, DataType.ARRAY_UB, DataType.ARRAY_B ->
asmgen.out(" tay | inx | lda $ESTACK_LO_HEX,x | sta $variablename,y") asmgen.out(" tay | inx | lda $ESTACK_LO_HEX,x | sta $variablename,y")
DataType.ARRAY_UW, DataType.ARRAY_W -> DataType.ARRAY_UW, DataType.ARRAY_W ->
asmgen.out(" asl a | tay | inx | lda $ESTACK_LO_HEX,x | sta $variablename,y | lda $ESTACK_HI_HEX,x | sta $variablename+1,y") asmgen.out(" asl a | tay | inx | lda $ESTACK_LO_HEX,x | sta $variablename,y | lda $ESTACK_HI_HEX,x | sta $variablename+1,y")

4
compiler/src/prog8/compiler/target/c64/codegen/BuiltinFunctionsAsmGen.kt
View File

@ -85,7 +85,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
outputPushAddressAndLenghtOfArray(fcall.arglist[0]) outputPushAddressAndLenghtOfArray(fcall.arglist[0])
val dt = fcall.arglist.single().inferType(program) val dt = fcall.arglist.single().inferType(program)
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_ub") DataType.ARRAY_UB, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_ub")
DataType.ARRAY_B -> asmgen.out(" jsr prog8_lib.func_${functionName}_b") DataType.ARRAY_B -> asmgen.out(" jsr prog8_lib.func_${functionName}_b")
DataType.ARRAY_UW -> asmgen.out(" jsr prog8_lib.func_${functionName}_uw") DataType.ARRAY_UW -> asmgen.out(" jsr prog8_lib.func_${functionName}_uw")
DataType.ARRAY_W -> asmgen.out(" jsr prog8_lib.func_${functionName}_w") DataType.ARRAY_W -> asmgen.out(" jsr prog8_lib.func_${functionName}_w")
@ -97,7 +97,7 @@ internal class BuiltinFunctionsAsmGen(private val program: Program, private val
outputPushAddressAndLenghtOfArray(fcall.arglist[0]) outputPushAddressAndLenghtOfArray(fcall.arglist[0])
val dt = fcall.arglist.single().inferType(program) val dt = fcall.arglist.single().inferType(program)
when (dt.typeOrElse(DataType.STRUCT)) { when (dt.typeOrElse(DataType.STRUCT)) {
DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR_S, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_b") DataType.ARRAY_B, DataType.ARRAY_UB, DataType.STR -> asmgen.out(" jsr prog8_lib.func_${functionName}_b")
DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out(" jsr prog8_lib.func_${functionName}_w") DataType.ARRAY_UW, DataType.ARRAY_W -> asmgen.out(" jsr prog8_lib.func_${functionName}_w")
DataType.ARRAY_F -> asmgen.out(" jsr c64flt.func_${functionName}_f") DataType.ARRAY_F -> asmgen.out(" jsr c64flt.func_${functionName}_f")
else -> throw AssemblyError("weird type $dt") else -> throw AssemblyError("weird type $dt")

6
compiler/src/prog8/compiler/target/c64/codegen/ExpressionsAsmGen.kt
View File

@ -172,12 +172,12 @@ internal class ExpressionsAsmGen(private val program: Program, private val asmge
DataType.UWORD, DataType.WORD -> { DataType.UWORD, DataType.WORD -> {
asmgen.out(" lda $varname | sta $ESTACK_LO_HEX,x | lda $varname+1 | sta $ESTACK_HI_HEX,x | dex") asmgen.out(" lda $varname | sta $ESTACK_LO_HEX,x | lda $varname+1 | sta $ESTACK_HI_HEX,x | dex")
} }
in ArrayDatatypes, in StringDatatypes -> {
asmgen.out(" lda #<$varname | sta $ESTACK_LO_HEX,x | lda #>$varname | sta $ESTACK_HI_HEX,x | dex")
}
DataType.FLOAT -> { DataType.FLOAT -> {
asmgen.out(" lda #<$varname | ldy #>$varname| jsr c64flt.push_float") asmgen.out(" lda #<$varname | ldy #>$varname| jsr c64flt.push_float")
} }
in IterableDatatypes -> {
asmgen.out(" lda #<$varname | sta $ESTACK_LO_HEX,x | lda #>$varname | sta $ESTACK_HI_HEX,x | dex")
}
else -> throw AssemblyError("stack push weird variable type $expr") else -> throw AssemblyError("stack push weird variable type $expr")
} }
} }

2
compiler/src/prog8/compiler/target/c64/codegen/ForLoopsAsmGen.kt
View File

@ -318,7 +318,7 @@ $endLabel inx""")
val iterableName = asmgen.asmIdentifierName(ident) val iterableName = asmgen.asmIdentifierName(ident)
val decl = ident.targetVarDecl(program.namespace)!! val decl = ident.targetVarDecl(program.namespace)!!
when(iterableDt) { when(iterableDt) {
DataType.STR, DataType.STR_S -> { DataType.STR -> {
if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A) if(stmt.loopRegister!=null && stmt.loopRegister!= Register.A)
throw AssemblyError("can only use A") throw AssemblyError("can only use A")
asmgen.out(""" asmgen.out("""

4
compiler/src/prog8/compiler/target/c64/codegen/FunctionCallAsmGen.kt
View File

@ -228,9 +228,9 @@ internal class FunctionCallAsmGen(private val program: Program, private val asmg
// we have a special rule for some types. // we have a special rule for some types.
// strings are assignable to UWORD, for example, and vice versa // strings are assignable to UWORD, for example, and vice versa
if(argType in StringDatatypes && paramType==DataType.UWORD) if(argType==DataType.STR && paramType==DataType.UWORD)
return true return true
if(argType==DataType.UWORD && paramType in StringDatatypes) if(argType==DataType.UWORD && paramType == DataType.STR)
return true return true
return false return false

2
compiler/src/prog8/compiler/target/c64/codegen/PostIncrDecrAsmGen.kt
View File

@ -123,7 +123,7 @@ internal class PostIncrDecrAsmGen(private val program: Program, private val asmg
private fun incrDecrArrayvalueWithIndexA(incr: Boolean, arrayDt: DataType, arrayVarName: String) { private fun incrDecrArrayvalueWithIndexA(incr: Boolean, arrayDt: DataType, arrayVarName: String) {
asmgen.out(" stx ${C64Zeropage.SCRATCH_REG_X} | tax") asmgen.out(" stx ${C64Zeropage.SCRATCH_REG_X} | tax")
when(arrayDt) { when(arrayDt) {
DataType.STR, DataType.STR_S, DataType.STR,
DataType.ARRAY_UB, DataType.ARRAY_B -> { DataType.ARRAY_UB, DataType.ARRAY_B -> {
asmgen.out(if(incr) " inc $arrayVarName,x" else " dec $arrayVarName,x") asmgen.out(if(incr) " inc $arrayVarName,x" else " dec $arrayVarName,x")
} }

13
compiler/src/prog8/functions/BuiltinFunctions.kt
View File

@ -88,7 +88,7 @@ val BuiltinFunctions = mapOf(
BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD), BuiltinFunctionParam("address", IterableDatatypes + DataType.UWORD),
BuiltinFunctionParam("numwords", setOf(DataType.UWORD)), BuiltinFunctionParam("numwords", setOf(DataType.UWORD)),
BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null), BuiltinFunctionParam("wordvalue", setOf(DataType.UWORD, DataType.WORD))), null),
"strlen" to FunctionSignature(true, listOf(BuiltinFunctionParam("string", StringDatatypes)), DataType.UBYTE, ::builtinStrlen) "strlen" to FunctionSignature(true, listOf(BuiltinFunctionParam("string", setOf(DataType.STR))), DataType.UBYTE, ::builtinStrlen)
) )
fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!! fun builtinMax(array: List<Number>): Number = array.maxBy { it.toDouble() }!!
@ -121,8 +121,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
if(!idt.isKnown) if(!idt.isKnown)
throw FatalAstException("couldn't determine type of iterable $arglist") throw FatalAstException("couldn't determine type of iterable $arglist")
return when(val dt = idt.typeOrElse(DataType.STRUCT)) { return when(val dt = idt.typeOrElse(DataType.STRUCT)) {
in NumericDatatypes -> dt DataType.STR, in NumericDatatypes -> dt
in StringDatatypes -> dt
in ArrayDatatypes -> ArrayElementTypes.getValue(dt) in ArrayDatatypes -> ArrayElementTypes.getValue(dt)
else -> throw FatalAstException("function '$function' requires one argument which is an iterable") else -> throw FatalAstException("function '$function' requires one argument which is an iterable")
} }
@ -145,8 +144,8 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
} }
"max", "min" -> { "max", "min" -> {
when(val dt = datatypeFromIterableArg(args.single())) { when(val dt = datatypeFromIterableArg(args.single())) {
DataType.STR -> InferredTypes.knownFor(DataType.UBYTE)
in NumericDatatypes -> InferredTypes.knownFor(dt) in NumericDatatypes -> InferredTypes.knownFor(dt)
in StringDatatypes -> InferredTypes.knownFor(DataType.UBYTE)
in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(dt)) in ArrayDatatypes -> InferredTypes.knownFor(ArrayElementTypes.getValue(dt))
else -> InferredTypes.unknown() else -> InferredTypes.unknown()
} }
@ -159,7 +158,7 @@ fun builtinFunctionReturnType(function: String, args: List<Expression>, program:
DataType.ARRAY_UB, DataType.ARRAY_UW -> InferredTypes.knownFor(DataType.UWORD) DataType.ARRAY_UB, DataType.ARRAY_UW -> InferredTypes.knownFor(DataType.UWORD)
DataType.ARRAY_B, DataType.ARRAY_W -> InferredTypes.knownFor(DataType.WORD) DataType.ARRAY_B, DataType.ARRAY_W -> InferredTypes.knownFor(DataType.WORD)
DataType.ARRAY_F -> InferredTypes.knownFor(DataType.FLOAT) DataType.ARRAY_F -> InferredTypes.knownFor(DataType.FLOAT)
in StringDatatypes -> InferredTypes.knownFor(DataType.UWORD) DataType.STR -> InferredTypes.knownFor(DataType.UWORD)
else -> InferredTypes.unknown() else -> InferredTypes.unknown()
} }
} }
@ -232,7 +231,7 @@ private fun builtinStrlen(args: List<Expression>, position: Position, program: P
if (args.size != 1) if (args.size != 1)
throw SyntaxError("strlen requires one argument", position) throw SyntaxError("strlen requires one argument", position)
val argument = args[0].constValue(program) ?: throw NotConstArgumentException() val argument = args[0].constValue(program) ?: throw NotConstArgumentException()
if(argument.type !in StringDatatypes) if(argument.type != DataType.STR)
throw SyntaxError("strlen must have string argument", position) throw SyntaxError("strlen must have string argument", position)
throw NotConstArgumentException() // this function is not considering the string argument a constant throw NotConstArgumentException() // this function is not considering the string argument a constant
@ -269,7 +268,7 @@ private fun builtinLen(args: List<Expression>, position: Position, program: Prog
throw CompilerException("array length exceeds byte limit ${target.position}") throw CompilerException("array length exceeds byte limit ${target.position}")
NumericLiteralValue.optimalInteger(arraySize, args[0].position) NumericLiteralValue.optimalInteger(arraySize, args[0].position)
} }
in StringDatatypes -> { DataType.STR -> {
val refLv = target.value as StringLiteralValue val refLv = target.value as StringLiteralValue
if(refLv.value.length>255) if(refLv.value.length>255)
throw CompilerException("string length exceeds byte limit ${refLv.position}") throw CompilerException("string length exceeds byte limit ${refLv.position}")

7
compiler/src/prog8/optimizer/ConstantFolding.kt
View File

@ -63,12 +63,6 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
return super.visit(decl) return super.visit(decl)
} }
} }
in StringDatatypes -> {
// nothing to do for strings
}
DataType.STRUCT -> {
// struct defintions don't have anything else in them
}
DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> { DataType.ARRAY_UB, DataType.ARRAY_B, DataType.ARRAY_UW, DataType.ARRAY_W -> {
val numericLv = decl.value as? NumericLiteralValue val numericLv = decl.value as? NumericLiteralValue
val rangeExpr = decl.value as? RangeExpr val rangeExpr = decl.value as? RangeExpr
@ -154,6 +148,7 @@ class ConstantFolding(private val program: Program) : IAstModifyingVisitor {
} }
else -> { else -> {
// nothing to do for this type // nothing to do for this type
// this includes strings and structs
} }
} }
} }

8
compiler/src/prog8/vm/RuntimeValue.kt
View File

@ -577,13 +577,7 @@ class RuntimeValueString(type: DataType, val str: String, val heapId: Int?): Run
} }
} }
override fun toString(): String { override fun toString(): String = if(type==DataType.STR) "str:$str" else "???"
return when (type) {
DataType.STR -> "str:$str"
DataType.STR_S -> "str_s:$str"
else -> "???"
}
}
override fun hashCode(): Int = Objects.hash(type, str) override fun hashCode(): Int = Objects.hash(type, str)

14
compiler/src/prog8/vm/astvm/AstVm.kt
View File

@ -577,7 +577,6 @@ class AstVm(val program: Program, compilationTarget: String) {
DataType.WORD -> mem.setSWord(address, (value as RuntimeValueNumeric).wordval!!) DataType.WORD -> mem.setSWord(address, (value as RuntimeValueNumeric).wordval!!)
DataType.FLOAT -> mem.setFloat(address, (value as RuntimeValueNumeric).floatval!!) DataType.FLOAT -> mem.setFloat(address, (value as RuntimeValueNumeric).floatval!!)
DataType.STR -> mem.setString(address, (value as RuntimeValueString).str) DataType.STR -> mem.setString(address, (value as RuntimeValueString).str)
DataType.STR_S -> mem.setScreencodeString(address, (value as RuntimeValueString).str)
else -> throw VmExecutionException("weird memaddress type $decl") else -> throw VmExecutionException("weird memaddress type $decl")
} }
} else } else
@ -613,7 +612,7 @@ class AstVm(val program: Program, compilationTarget: String) {
if (value.type != DataType.FLOAT) if (value.type != DataType.FLOAT)
throw VmExecutionException("new value is of different datatype ${value.type} for $array") throw VmExecutionException("new value is of different datatype ${value.type} for $array")
} }
DataType.STR, DataType.STR_S -> { DataType.STR -> {
if (value.type !in ByteDatatypes) if (value.type !in ByteDatatypes)
throw VmExecutionException("new value is of different datatype ${value.type} for $array") throw VmExecutionException("new value is of different datatype ${value.type} for $array")
} }
@ -621,7 +620,7 @@ class AstVm(val program: Program, compilationTarget: String) {
} }
if (array.type in ArrayDatatypes) if (array.type in ArrayDatatypes)
(array as RuntimeValueArray).array[index.integerValue()] = value.numericValue() (array as RuntimeValueArray).array[index.integerValue()] = value.numericValue()
else if (array.type in StringDatatypes) { else if (array.type == DataType.STR) {
val indexInt = index.integerValue() val indexInt = index.integerValue()
val newchr = value.numericValue().toChar().toString() val newchr = value.numericValue().toChar().toString()
val newstr = (array as RuntimeValueString).str.replaceRange(indexInt, indexInt + 1, newchr) val newstr = (array as RuntimeValueString).str.replaceRange(indexInt, indexInt + 1, newchr)
@ -783,13 +782,8 @@ class AstVm(val program: Program, compilationTarget: String) {
return result return result
} }
private fun getAsciiStringFromRuntimeVars(heapId: Int): String { private fun getAsciiStringFromRuntimeVars(heapId: Int): String =
val stringvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueString (runtimeVariables.getByHeapId(heapId) as RuntimeValueString).str
return when (stringvar.type) {
DataType.STR, DataType.STR_S -> stringvar.str
else -> throw VmExecutionException("weird string type")
}
}
private fun getArrayFromRuntimeVars(heapId: Int): IntArray { private fun getArrayFromRuntimeVars(heapId: Int): IntArray {
val arrayvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueArray val arrayvar = runtimeVariables.getByHeapId(heapId) as RuntimeValueArray

1
compiler/src/prog8/vm/astvm/Expressions.kt
View File

@ -125,7 +125,6 @@ fun evaluate(expr: Expression, ctx: EvalContext): RuntimeValueBase {
DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address)) DataType.WORD -> RuntimeValueNumeric(DataType.WORD, ctx.mem.getSWord(address))
DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address)) DataType.FLOAT -> RuntimeValueNumeric(DataType.FLOAT, ctx.mem.getFloat(address))
DataType.STR -> RuntimeValueString(DataType.STR, ctx.mem.getString(address), null) DataType.STR -> RuntimeValueString(DataType.STR, ctx.mem.getString(address), null)
DataType.STR_S -> RuntimeValueString(DataType.STR_S, ctx.mem.getScreencodeString(address)!!, null)
else -> throw VmExecutionException("unexpected datatype $variable") else -> throw VmExecutionException("unexpected datatype $variable")
} }
} }

5
docs/source/programming.rst
View File

@ -271,9 +271,8 @@ Strings
Strings are a sequence of characters enclosed in ``"`` quotes. The length is limited to 255 characters. Strings are a sequence of characters enclosed in ``"`` quotes. The length is limited to 255 characters.
They're stored and treated much the same as a byte array, They're stored and treated much the same as a byte array,
but they have some special properties because they are considered to be *text*. but they have some special properties because they are considered to be *text*.
Strings in your source code files will be encoded (translated from ASCII/UTF-8) into either CBM PETSCII or C-64 screencodes. Strings in your source code files will be encoded (translated from ASCII/UTF-8) into the byte-encoding
PETSCII is the default choice. If you need screencodes (also called 'poke' codes) instead, that is used on the target platform. For the C-64, this is CBM PETSCII.
you have to use the ``str_s`` variants of the string type identifier.
You can concatenate two string literals using '+' (not very useful though) or repeat You can concatenate two string literals using '+' (not very useful though) or repeat
a string literal a given number of times using '*':: a string literal a given number of times using '*'::

2
docs/source/syntaxreference.rst
View File

@ -268,8 +268,6 @@ type identifier type storage size example var declara
``float[]`` floating-point array depends on value ``float[] myvar = [1.1, 2.2, 3.3, 4.4]`` ``float[]`` floating-point array depends on value ``float[] myvar = [1.1, 2.2, 3.3, 4.4]``
``str`` string (petscii) varies ``str myvar = "hello."`` ``str`` string (petscii) varies ``str myvar = "hello."``
implicitly terminated by a 0-byte implicitly terminated by a 0-byte
``str_s`` string (screencodes) varies ``str_s myvar = "hello."``
implicitly terminated by a 0-byte
=============== ======================= ================= ========================================= =============== ======================= ================= =========================================
**arrays:** you can split an array initializer list over several lines if you want. When an initialization **arrays:** you can split an array initializer list over several lines if you want. When an initialization

26
examples/screencodes.p8 Normal file
View File

@ -0,0 +1,26 @@
%import c64lib
%import c64utils
%zeropage basicsafe
main {
sub start() {
c64.VMCSB |= 2 ; switch to lowercase charset
str s1 = "HELLO hello 1234 @[/]\n"
str s2 = "HELLO hello 1234 @[/]\n" ; TODO as c64scr
c64scr.print("\n\n\n\nString output via print:\n")
c64scr.print(s1)
c64scr.print(s2)
c64scr.print("\nThe top two screen lines are set via screencodes.\n")
ubyte i
for i in 0 to len(s1)-1 {
@($0400+i) = s1[i]
@($0400+40+i) = s2[i]
}
}
}

15
examples/testarrays.p8
View File

@ -11,8 +11,9 @@ main {
c64scr.print("this is only a parser/compiler test\n") c64scr.print("this is only a parser/compiler test\n")
return return
str s1 = "irmen" str s1 = "hello"
str_s s2 = "hello" str s2 = "screencodes" ; TODO as c64sc
&str ms1 = $c000 &str ms1 = $c000
@ -37,7 +38,6 @@ main {
; read array ; read array
A=s1[2] A=s1[2]
ub=s1[2] ub=s1[2]
ub=s2[2]
bb=barray[2] bb=barray[2]
ub=ubarray[2] ub=ubarray[2]
ww=warray[2] ww=warray[2]
@ -52,8 +52,7 @@ main {
fl=mflarray[2] fl=mflarray[2]
A=s1[A] A=s1[A]
ub=s2[A] ub=s1[A]
ub=s2[A]
bb=barray[A] bb=barray[A]
ub=ubarray[A] ub=ubarray[A]
ww=warray[A] ww=warray[A]
@ -69,7 +68,6 @@ main {
A=s1[bb] A=s1[bb]
ub=s1[bb] ub=s1[bb]
ub=s2[bb]
bb=barray[bb] bb=barray[bb]
ub=ubarray[bb] ub=ubarray[bb]
ww=warray[bb] ww=warray[bb]
@ -85,7 +83,6 @@ main {
A=s1[bb*3] A=s1[bb*3]
ub=s1[bb*3] ub=s1[bb*3]
ub=s2[bb*3]
bb=barray[bb*3] bb=barray[bb*3]
ub=ubarray[bb*3] ub=ubarray[bb*3]
ww=warray[bb*3] ww=warray[bb*3]
@ -104,7 +101,6 @@ main {
barray[2]-- barray[2]--
s1[2] = A s1[2] = A
s1[2] = ub s1[2] = ub
s2[2] = ub
barray[2] = bb barray[2] = bb
ubarray[2] = ub ubarray[2] = ub
warray[2] = ww warray[2] = ww
@ -121,7 +117,6 @@ main {
mflarray[2] = fl mflarray[2] = fl
s1[A] = ub s1[A] = ub
s2[A] = ub
barray[A] = bb barray[A] = bb
ubarray[A] = ub ubarray[A] = ub
warray[A] = ww warray[A] = ww
@ -129,7 +124,6 @@ main {
flarray[A] = fl flarray[A] = fl
s1[bb] = ub s1[bb] = ub
s2[bb] = ub
barray[bb] = bb barray[bb] = bb
ubarray[bb] = ub ubarray[bb] = ub
warray[bb] = ww warray[bb] = ww
@ -137,7 +131,6 @@ main {
flarray[bb] = fl flarray[bb] = fl
s1[bb*3] = ub s1[bb*3] = ub
s2[bb*3] = ub
barray[bb*3] = bb barray[bb*3] = bb
ubarray[bb*3] = ub ubarray[bb*3] = ub
warray[bb*3] = ww warray[bb*3] = ww

2
parser/antlr/prog8.g4
View File

@ -126,7 +126,7 @@ memoryvardecl: ADDRESS_OF varinitializer;
structdecl: 'struct' identifier '{' EOL vardecl ( EOL vardecl)* EOL? '}' EOL; structdecl: 'struct' identifier '{' EOL vardecl ( EOL vardecl)* EOL? '}' EOL;
datatype: 'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' | 'str_s' ; datatype: 'ubyte' | 'byte' | 'uword' | 'word' | 'float' | 'str' ;
arrayindex: '[' expression ']' ; arrayindex: '[' expression ']' ;

625
parser/src/prog8/parser/prog8Lexer.java
View File

@ -34,10 +34,10 @@ public class prog8Lexer extends Lexer {
T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94, T__87=88, T__88=89, T__89=90, T__90=91, T__91=92, T__92=93, T__93=94,
T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101, T__94=95, T__95=96, T__96=97, T__97=98, T__98=99, T__99=100, T__100=101,
T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107, T__101=102, T__102=103, T__103=104, T__104=105, T__105=106, T__106=107,
T__107=108, T__108=109, T__109=110, LINECOMMENT=111, COMMENT=112, WS=113, T__107=108, T__108=109, LINECOMMENT=110, COMMENT=111, WS=112, EOL=113,
EOL=114, NAME=115, DEC_INTEGER=116, HEX_INTEGER=117, BIN_INTEGER=118, NAME=114, DEC_INTEGER=115, HEX_INTEGER=116, BIN_INTEGER=117, ADDRESS_OF=118,
ADDRESS_OF=119, FLOAT_NUMBER=120, STRING=121, INLINEASMBLOCK=122, SINGLECHAR=123, FLOAT_NUMBER=119, STRING=120, INLINEASMBLOCK=121, SINGLECHAR=122, ZEROPAGE=123,
ZEROPAGE=124, ARRAYSIG=125; ARRAYSIG=124;
public static String[] channelNames = { public static String[] channelNames = {
"DEFAULT_TOKEN_CHANNEL", "HIDDEN" "DEFAULT_TOKEN_CHANNEL", "HIDDEN"
}; };
@ -61,8 +61,8 @@ public class prog8Lexer extends Lexer {
"T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88", "T__81", "T__82", "T__83", "T__84", "T__85", "T__86", "T__87", "T__88",
"T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96", "T__89", "T__90", "T__91", "T__92", "T__93", "T__94", "T__95", "T__96",
"T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104", "T__97", "T__98", "T__99", "T__100", "T__101", "T__102", "T__103", "T__104",
"T__105", "T__106", "T__107", "T__108", "T__109", "LINECOMMENT", "COMMENT", "T__105", "T__106", "T__107", "T__108", "LINECOMMENT", "COMMENT", "WS",
"WS", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "EOL", "NAME", "DEC_INTEGER", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF",
"FLOAT_NUMBER", "FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK", "FLOAT_NUMBER", "FNUMBER", "STRING_ESCAPE_SEQ", "STRING", "INLINEASMBLOCK",
"SINGLECHAR", "ZEROPAGE", "ARRAYSIG" "SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
}; };
@ -74,19 +74,19 @@ public class prog8Lexer extends Lexer {
null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'", null, "':'", "'goto'", "'%output'", "'%launcher'", "'%zeropage'", "'%zpreserved'",
"'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'", "'%address'", "'%import'", "'%breakpoint'", "'%asminclude'", "'%asmbinary'",
"'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'", "'%option'", "','", "'='", "'const'", "'struct'", "'{'", "'}'", "'ubyte'",
"'byte'", "'uword'", "'word'", "'float'", "'str'", "'str_s'", "'['", "'byte'", "'uword'", "'word'", "'float'", "'str'", "'['", "']'", "'+='",
"']'", "'+='", "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'-='", "'/='", "'*='", "'**='", "'&='", "'|='", "'^='", "'%='", "'<<='",
"'%='", "'<<='", "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'>>='", "'++'", "'--'", "'+'", "'-'", "'~'", "'**'", "'*'", "'/'", "'%'",
"'*'", "'/'", "'%'", "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'<<'", "'>>'", "'<'", "'>'", "'<='", "'>='", "'=='", "'!='", "'^'",
"'!='", "'^'", "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'|'", "'to'", "'step'", "'and'", "'or'", "'xor'", "'not'", "'('", "')'",
"'('", "')'", "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'as'", "'@'", "'return'", "'break'", "'continue'", "'.'", "'A'", "'X'",
"'A'", "'X'", "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Y'", "'AX'", "'AY'", "'XY'", "'Pc'", "'Pz'", "'Pn'", "'Pv'", "'.w'",
"'Pv'", "'.w'", "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'true'", "'false'", "'%asm'", "'sub'", "'->'", "'asmsub'", "'stack'",
"'stack'", "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'clobbers'", "'if'", "'else'", "'if_cs'", "'if_cc'", "'if_eq'", "'if_z'",
"'if_z'", "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_ne'", "'if_nz'", "'if_pl'", "'if_pos'", "'if_mi'", "'if_neg'", "'if_vs'",
"'if_vs'", "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'if_vc'", "'for'", "'in'", "'while'", "'repeat'", "'until'", "'when'",
"'when'", null, null, null, null, null, null, null, null, "'&'", null, null, null, null, null, null, null, null, null, "'&'", null, null, null,
null, null, null, "'@zp'", "'[]'" null, "'@zp'", "'[]'"
}; };
} }
private static final String[] _LITERAL_NAMES = makeLiteralNames(); private static final String[] _LITERAL_NAMES = makeLiteralNames();
@ -101,7 +101,7 @@ public class prog8Lexer extends Lexer {
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null, null,
null, null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER", null, null, "LINECOMMENT", "COMMENT", "WS", "EOL", "NAME", "DEC_INTEGER",
"HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING", "HEX_INTEGER", "BIN_INTEGER", "ADDRESS_OF", "FLOAT_NUMBER", "STRING",
"INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG" "INLINEASMBLOCK", "SINGLECHAR", "ZEROPAGE", "ARRAYSIG"
}; };
@ -167,13 +167,13 @@ public class prog8Lexer extends Lexer {
@Override @Override
public void action(RuleContext _localctx, int ruleIndex, int actionIndex) { public void action(RuleContext _localctx, int ruleIndex, int actionIndex) {
switch (ruleIndex) { switch (ruleIndex) {
case 122: case 121:
STRING_action((RuleContext)_localctx, actionIndex); STRING_action((RuleContext)_localctx, actionIndex);
break; break;
case 123: case 122:
INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex); INLINEASMBLOCK_action((RuleContext)_localctx, actionIndex);
break; break;
case 124: case 123:
SINGLECHAR_action((RuleContext)_localctx, actionIndex); SINGLECHAR_action((RuleContext)_localctx, actionIndex);
break; break;
} }
@ -213,297 +213,294 @@ public class prog8Lexer extends Lexer {
} }
public static final String _serializedATN = public static final String _serializedATN =
"\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2\177\u036e\b\1\4\2"+ "\3\u608b\ua72a\u8133\ub9ed\u417c\u3be7\u7786\u5964\2~\u0366\b\1\4\2\t"+
"\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"+ "\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"+
"\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\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"+
"\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"+ "\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"+
"\t\31\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t"+ "\4\32\t\32\4\33\t\33\4\34\t\34\4\35\t\35\4\36\t\36\4\37\t\37\4 \t \4!"+
" \4!\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t"+ "\t!\4\"\t\"\4#\t#\4$\t$\4%\t%\4&\t&\4\'\t\'\4(\t(\4)\t)\4*\t*\4+\t+\4"+
"+\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,\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"+
"\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"+ "\64\4\65\t\65\4\66\t\66\4\67\t\67\48\t8\49\t9\4:\t:\4;\t;\4<\t<\4=\t="+
"=\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4"+ "\4>\t>\4?\t?\4@\t@\4A\tA\4B\tB\4C\tC\4D\tD\4E\tE\4F\tF\4G\tG\4H\tH\4I"+
"I\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\t"+ "\tI\4J\tJ\4K\tK\4L\tL\4M\tM\4N\tN\4O\tO\4P\tP\4Q\tQ\4R\tR\4S\tS\4T\tT"+
"T\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_"+ "\4U\tU\4V\tV\4W\tW\4X\tX\4Y\tY\4Z\tZ\4[\t[\4\\\t\\\4]\t]\4^\t^\4_\t_\4"+
"\4`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k"+ "`\t`\4a\ta\4b\tb\4c\tc\4d\td\4e\te\4f\tf\4g\tg\4h\th\4i\ti\4j\tj\4k\t"+
"\tk\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv"+ "k\4l\tl\4m\tm\4n\tn\4o\to\4p\tp\4q\tq\4r\tr\4s\ts\4t\tt\4u\tu\4v\tv\4"+
"\4w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\4\u0080\t"+ "w\tw\4x\tx\4y\ty\4z\tz\4{\t{\4|\t|\4}\t}\4~\t~\4\177\t\177\3\2\3\2\3\3"+
"\u0080\3\2\3\2\3\3\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5"+ "\3\3\3\3\3\3\3\3\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\4\3\5\3\5\3\5\3\5\3\5\3"+
"\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3"+ "\5\3\5\3\5\3\5\3\5\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\6\3\7\3\7\3\7"+
"\6\3\6\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b"+ "\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\7\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3\b\3"+
"\3\b\3\b\3\b\3\b\3\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3"+ "\b\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\t\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n"+
"\n\3\n\3\n\3\n\3\n\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13"+ "\3\n\3\n\3\n\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3\13\3"+
"\3\13\3\13\3\13\3\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3"+ "\13\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\f\3\r\3\r\3\r\3\r\3\r\3"+
"\r\3\r\3\r\3\r\3\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20"+ "\r\3\r\3\r\3\16\3\16\3\17\3\17\3\20\3\20\3\20\3\20\3\20\3\20\3\21\3\21"+
"\3\20\3\21\3\21\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24"+ "\3\21\3\21\3\21\3\21\3\21\3\22\3\22\3\23\3\23\3\24\3\24\3\24\3\24\3\24"+
"\3\24\3\24\3\24\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26"+ "\3\24\3\25\3\25\3\25\3\25\3\25\3\26\3\26\3\26\3\26\3\26\3\26\3\27\3\27"+
"\3\26\3\27\3\27\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31"+ "\3\27\3\27\3\27\3\30\3\30\3\30\3\30\3\30\3\30\3\31\3\31\3\31\3\31\3\32"+
"\3\31\3\31\3\32\3\32\3\32\3\32\3\32\3\32\3\33\3\33\3\34\3\34\3\35\3\35"+ "\3\32\3\33\3\33\3\34\3\34\3\34\3\35\3\35\3\35\3\36\3\36\3\36\3\37\3\37"+
"\3\35\3\36\3\36\3\36\3\37\3\37\3\37\3 \3 \3 \3!\3!\3!\3!\3\"\3\"\3\"\3"+ "\3\37\3 \3 \3 \3 \3!\3!\3!\3\"\3\"\3\"\3#\3#\3#\3$\3$\3$\3%\3%\3%\3%\3"+
"#\3#\3#\3$\3$\3$\3%\3%\3%\3&\3&\3&\3&\3\'\3\'\3\'\3\'\3(\3(\3(\3)\3)\3"+ "&\3&\3&\3&\3\'\3\'\3\'\3(\3(\3(\3)\3)\3*\3*\3+\3+\3,\3,\3,\3-\3-\3.\3"+
")\3*\3*\3+\3+\3,\3,\3-\3-\3-\3.\3.\3/\3/\3\60\3\60\3\61\3\61\3\61\3\62"+ ".\3/\3/\3\60\3\60\3\60\3\61\3\61\3\61\3\62\3\62\3\63\3\63\3\64\3\64\3"+
"\3\62\3\62\3\63\3\63\3\64\3\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67"+ "\64\3\65\3\65\3\65\3\66\3\66\3\66\3\67\3\67\3\67\38\38\39\39\3:\3:\3:"+
"\3\67\38\38\38\39\39\3:\3:\3;\3;\3;\3<\3<\3<\3<\3<\3=\3=\3=\3=\3>\3>\3"+ "\3;\3;\3;\3;\3;\3<\3<\3<\3<\3=\3=\3=\3>\3>\3>\3>\3?\3?\3?\3?\3@\3@\3A"+
">\3?\3?\3?\3?\3@\3@\3@\3@\3A\3A\3B\3B\3C\3C\3C\3D\3D\3E\3E\3E\3E\3E\3"+ "\3A\3B\3B\3B\3C\3C\3D\3D\3D\3D\3D\3D\3D\3E\3E\3E\3E\3E\3E\3F\3F\3F\3F"+
"E\3E\3F\3F\3F\3F\3F\3F\3G\3G\3G\3G\3G\3G\3G\3G\3G\3H\3H\3I\3I\3J\3J\3"+ "\3F\3F\3F\3F\3F\3G\3G\3H\3H\3I\3I\3J\3J\3K\3K\3K\3L\3L\3L\3M\3M\3M\3N"+
"K\3K\3L\3L\3L\3M\3M\3M\3N\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3"+ "\3N\3N\3O\3O\3O\3P\3P\3P\3Q\3Q\3Q\3R\3R\3R\3S\3S\3S\3S\3S\3T\3T\3T\3T"+
"S\3S\3S\3T\3T\3T\3T\3T\3U\3U\3U\3U\3U\3U\3V\3V\3V\3V\3V\3W\3W\3W\3W\3"+ "\3T\3T\3U\3U\3U\3U\3U\3V\3V\3V\3V\3W\3W\3W\3X\3X\3X\3X\3X\3X\3X\3Y\3Y"+
"X\3X\3X\3Y\3Y\3Y\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3[\3[\3[\3[\3"+ "\3Y\3Y\3Y\3Y\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3Z\3[\3[\3[\3\\\3\\\3\\\3\\\3\\\3"+
"[\3[\3\\\3\\\3\\\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3"+ "]\3]\3]\3]\3]\3]\3^\3^\3^\3^\3^\3^\3_\3_\3_\3_\3_\3_\3`\3`\3`\3`\3`\3"+
"`\3`\3`\3`\3`\3`\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3"+ "a\3a\3a\3a\3a\3a\3b\3b\3b\3b\3b\3b\3c\3c\3c\3c\3c\3c\3d\3d\3d\3d\3d\3"+
"d\3d\3d\3d\3d\3d\3e\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3"+ "d\3d\3e\3e\3e\3e\3e\3e\3f\3f\3f\3f\3f\3f\3f\3g\3g\3g\3g\3g\3g\3h\3h\3"+
"g\3g\3g\3h\3h\3h\3h\3h\3h\3i\3i\3i\3i\3i\3i\3j\3j\3j\3j\3k\3k\3k\3l\3"+ "h\3h\3h\3h\3i\3i\3i\3i\3j\3j\3j\3k\3k\3k\3k\3k\3k\3l\3l\3l\3l\3l\3l\3"+
"l\3l\3l\3l\3l\3m\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3n\3o\3o\3o\3o\3o\3"+ "l\3m\3m\3m\3m\3m\3m\3n\3n\3n\3n\3n\3o\3o\7o\u02ec\no\fo\16o\u02ef\13o"+
"p\3p\7p\u02f4\np\fp\16p\u02f7\13p\3p\3p\3p\3p\3q\3q\7q\u02ff\nq\fq\16"+ "\3o\3o\3o\3o\3p\3p\7p\u02f7\np\fp\16p\u02fa\13p\3p\3p\3q\3q\3q\3q\3r\6"+
"q\u0302\13q\3q\3q\3r\3r\3r\3r\3s\6s\u030b\ns\rs\16s\u030c\3t\3t\7t\u0311"+ "r\u0303\nr\rr\16r\u0304\3s\3s\7s\u0309\ns\fs\16s\u030c\13s\3t\3t\3t\6"+
"\nt\ft\16t\u0314\13t\3u\3u\3u\6u\u0319\nu\ru\16u\u031a\5u\u031d\nu\3v"+ "t\u0311\nt\rt\16t\u0312\5t\u0315\nt\3u\3u\6u\u0319\nu\ru\16u\u031a\3v"+
"\3v\6v\u0321\nv\rv\16v\u0322\3w\3w\6w\u0327\nw\rw\16w\u0328\3x\3x\3y\3"+ "\3v\6v\u031f\nv\rv\16v\u0320\3w\3w\3x\3x\3x\5x\u0328\nx\3x\5x\u032b\n"+
"y\3y\5y\u0330\ny\3y\5y\u0333\ny\3z\6z\u0336\nz\rz\16z\u0337\3z\3z\6z\u033c"+ "x\3y\6y\u032e\ny\ry\16y\u032f\3y\3y\6y\u0334\ny\ry\16y\u0335\5y\u0338"+
"\nz\rz\16z\u033d\5z\u0340\nz\3{\3{\3{\3{\5{\u0346\n{\3|\3|\3|\7|\u034b"+ "\ny\3z\3z\3z\3z\5z\u033e\nz\3{\3{\3{\7{\u0343\n{\f{\16{\u0346\13{\3{\3"+
"\n|\f|\16|\u034e\13|\3|\3|\3|\3}\3}\3}\3}\6}\u0357\n}\r}\16}\u0358\3}"+ "{\3{\3|\3|\3|\3|\6|\u034f\n|\r|\16|\u0350\3|\3|\3|\3|\3|\3}\3}\3}\5}\u035b"+
"\3}\3}\3}\3}\3~\3~\3~\5~\u0363\n~\3~\3~\3~\3\177\3\177\3\177\3\177\3\u0080"+ "\n}\3}\3}\3}\3~\3~\3~\3~\3\177\3\177\3\177\3\u0350\2\u0080\3\3\5\4\7\5"+
"\3\u0080\3\u0080\3\u0358\2\u0081\3\3\5\4\7\5\t\6\13\7\r\b\17\t\21\n\23"+ "\t\6\13\7\r\b\17\t\21\n\23\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23"+
"\13\25\f\27\r\31\16\33\17\35\20\37\21!\22#\23%\24\'\25)\26+\27-\30/\31"+ "%\24\'\25)\26+\27-\30/\31\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G"+
"\61\32\63\33\65\34\67\359\36;\37= ?!A\"C#E$G%I&K\'M(O)Q*S+U,W-Y.[/]\60"+ "%I&K\'M(O)Q*S+U,W-Y.[/]\60_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{"+
"_\61a\62c\63e\64g\65i\66k\67m8o9q:s;u<w=y>{?}@\177A\u0081B\u0083C\u0085"+ "?}@\177A\u0081B\u0083C\u0085D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091"+
"D\u0087E\u0089F\u008bG\u008dH\u008fI\u0091J\u0093K\u0095L\u0097M\u0099"+ "J\u0093K\u0095L\u0097M\u0099N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5"+
"N\u009bO\u009dP\u009fQ\u00a1R\u00a3S\u00a5T\u00a7U\u00a9V\u00abW\u00ad"+ "T\u00a7U\u00a9V\u00abW\u00adX\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9"+
"X\u00afY\u00b1Z\u00b3[\u00b5\\\u00b7]\u00b9^\u00bb_\u00bd`\u00bfa\u00c1"+ "^\u00bb_\u00bd`\u00bfa\u00c1b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cd"+
"b\u00c3c\u00c5d\u00c7e\u00c9f\u00cbg\u00cdh\u00cfi\u00d1j\u00d3k\u00d5"+ "h\u00cfi\u00d1j\u00d3k\u00d5l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1"+
"l\u00d7m\u00d9n\u00dbo\u00ddp\u00dfq\u00e1r\u00e3s\u00e5t\u00e7u\u00e9"+ "r\u00e3s\u00e5t\u00e7u\u00e9v\u00ebw\u00edx\u00efy\u00f1\2\u00f3\2\u00f5"+
"v\u00ebw\u00edx\u00efy\u00f1z\u00f3\2\u00f5\2\u00f7{\u00f9|\u00fb}\u00fd"+ "z\u00f7{\u00f9|\u00fb}\u00fd~\3\2\n\4\2\f\f\17\17\4\2\13\13\"\"\5\2C\\"+
"~\u00ff\177\3\2\n\4\2\f\f\17\17\4\2\13\13\"\"\5\2C\\aac|\6\2\62;C\\aa"+ "aac|\6\2\62;C\\aac|\5\2\62;CHch\4\2GGgg\4\2--//\6\2\f\f\16\17$$^^\2\u0375"+
"c|\5\2\62;CHch\4\2GGgg\4\2--//\6\2\f\f\16\17$$^^\2\u037d\2\3\3\2\2\2\2"+ "\2\3\3\2\2\2\2\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2"+
"\5\3\2\2\2\2\7\3\2\2\2\2\t\3\2\2\2\2\13\3\2\2\2\2\r\3\2\2\2\2\17\3\2\2"+ "\2\2\2\17\3\2\2\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2"+
"\2\2\21\3\2\2\2\2\23\3\2\2\2\2\25\3\2\2\2\2\27\3\2\2\2\2\31\3\2\2\2\2"+ "\2\31\3\2\2\2\2\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2"+
"\33\3\2\2\2\2\35\3\2\2\2\2\37\3\2\2\2\2!\3\2\2\2\2#\3\2\2\2\2%\3\2\2\2"+ "\2\2\2%\3\2\2\2\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2"+
"\2\'\3\2\2\2\2)\3\2\2\2\2+\3\2\2\2\2-\3\2\2\2\2/\3\2\2\2\2\61\3\2\2\2"+ "\2\2\61\3\2\2\2\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3"+
"\2\63\3\2\2\2\2\65\3\2\2\2\2\67\3\2\2\2\29\3\2\2\2\2;\3\2\2\2\2=\3\2\2"+ "\2\2\2\2=\3\2\2\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2"+
"\2\2?\3\2\2\2\2A\3\2\2\2\2C\3\2\2\2\2E\3\2\2\2\2G\3\2\2\2\2I\3\2\2\2\2"+ "\2\2I\3\2\2\2\2K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2"+
"K\3\2\2\2\2M\3\2\2\2\2O\3\2\2\2\2Q\3\2\2\2\2S\3\2\2\2\2U\3\2\2\2\2W\3"+ "U\3\2\2\2\2W\3\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3"+
"\2\2\2\2Y\3\2\2\2\2[\3\2\2\2\2]\3\2\2\2\2_\3\2\2\2\2a\3\2\2\2\2c\3\2\2"+ "\2\2\2\2c\3\2\2\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2"+
"\2\2e\3\2\2\2\2g\3\2\2\2\2i\3\2\2\2\2k\3\2\2\2\2m\3\2\2\2\2o\3\2\2\2\2"+ "\2\2o\3\2\2\2\2q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2"+
"q\3\2\2\2\2s\3\2\2\2\2u\3\2\2\2\2w\3\2\2\2\2y\3\2\2\2\2{\3\2\2\2\2}\3"+ "{\3\2\2\2\2}\3\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085"+
"\2\2\2\2\177\3\2\2\2\2\u0081\3\2\2\2\2\u0083\3\2\2\2\2\u0085\3\2\2\2\2"+ "\3\2\2\2\2\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2"+
"\u0087\3\2\2\2\2\u0089\3\2\2\2\2\u008b\3\2\2\2\2\u008d\3\2\2\2\2\u008f"+ "\2\2\u008f\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097"+
"\3\2\2\2\2\u0091\3\2\2\2\2\u0093\3\2\2\2\2\u0095\3\2\2\2\2\u0097\3\2\2"+ "\3\2\2\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2"+
"\2\2\u0099\3\2\2\2\2\u009b\3\2\2\2\2\u009d\3\2\2\2\2\u009f\3\2\2\2\2\u00a1"+ "\2\2\u00a1\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9"+
"\3\2\2\2\2\u00a3\3\2\2\2\2\u00a5\3\2\2\2\2\u00a7\3\2\2\2\2\u00a9\3\2\2"+ "\3\2\2\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2"+
"\2\2\u00ab\3\2\2\2\2\u00ad\3\2\2\2\2\u00af\3\2\2\2\2\u00b1\3\2\2\2\2\u00b3"+ "\2\2\u00b3\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb"+
"\3\2\2\2\2\u00b5\3\2\2\2\2\u00b7\3\2\2\2\2\u00b9\3\2\2\2\2\u00bb\3\2\2"+ "\3\2\2\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2"+
"\2\2\u00bd\3\2\2\2\2\u00bf\3\2\2\2\2\u00c1\3\2\2\2\2\u00c3\3\2\2\2\2\u00c5"+ "\2\2\u00c5\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd"+
"\3\2\2\2\2\u00c7\3\2\2\2\2\u00c9\3\2\2\2\2\u00cb\3\2\2\2\2\u00cd\3\2\2"+ "\3\2\2\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2"+
"\2\2\u00cf\3\2\2\2\2\u00d1\3\2\2\2\2\u00d3\3\2\2\2\2\u00d5\3\2\2\2\2\u00d7"+ "\2\2\u00d7\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df"+
"\3\2\2\2\2\u00d9\3\2\2\2\2\u00db\3\2\2\2\2\u00dd\3\2\2\2\2\u00df\3\2\2"+ "\3\2\2\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2"+
"\2\2\u00e1\3\2\2\2\2\u00e3\3\2\2\2\2\u00e5\3\2\2\2\2\u00e7\3\2\2\2\2\u00e9"+ "\2\2\u00e9\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f5"+
"\3\2\2\2\2\u00eb\3\2\2\2\2\u00ed\3\2\2\2\2\u00ef\3\2\2\2\2\u00f1\3\2\2"+ "\3\2\2\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2"+
"\2\2\u00f7\3\2\2\2\2\u00f9\3\2\2\2\2\u00fb\3\2\2\2\2\u00fd\3\2\2\2\2\u00ff"+ "\2\3\u00ff\3\2\2\2\5\u0101\3\2\2\2\7\u0106\3\2\2\2\t\u010e\3\2\2\2\13"+
"\3\2\2\2\3\u0101\3\2\2\2\5\u0103\3\2\2\2\7\u0108\3\2\2\2\t\u0110\3\2\2"+ "\u0118\3\2\2\2\r\u0122\3\2\2\2\17\u012e\3\2\2\2\21\u0137\3\2\2\2\23\u013f"+
"\2\13\u011a\3\2\2\2\r\u0124\3\2\2\2\17\u0130\3\2\2\2\21\u0139\3\2\2\2"+ "\3\2\2\2\25\u014b\3\2\2\2\27\u0157\3\2\2\2\31\u0162\3\2\2\2\33\u016a\3"+
"\23\u0141\3\2\2\2\25\u014d\3\2\2\2\27\u0159\3\2\2\2\31\u0164\3\2\2\2\33"+ "\2\2\2\35\u016c\3\2\2\2\37\u016e\3\2\2\2!\u0174\3\2\2\2#\u017b\3\2\2\2"+
"\u016c\3\2\2\2\35\u016e\3\2\2\2\37\u0170\3\2\2\2!\u0176\3\2\2\2#\u017d"+ "%\u017d\3\2\2\2\'\u017f\3\2\2\2)\u0185\3\2\2\2+\u018a\3\2\2\2-\u0190\3"+
"\3\2\2\2%\u017f\3\2\2\2\'\u0181\3\2\2\2)\u0187\3\2\2\2+\u018c\3\2\2\2"+ "\2\2\2/\u0195\3\2\2\2\61\u019b\3\2\2\2\63\u019f\3\2\2\2\65\u01a1\3\2\2"+
"-\u0192\3\2\2\2/\u0197\3\2\2\2\61\u019d\3\2\2\2\63\u01a1\3\2\2\2\65\u01a7"+ "\2\67\u01a3\3\2\2\29\u01a6\3\2\2\2;\u01a9\3\2\2\2=\u01ac\3\2\2\2?\u01af"+
"\3\2\2\2\67\u01a9\3\2\2\29\u01ab\3\2\2\2;\u01ae\3\2\2\2=\u01b1\3\2\2\2"+ "\3\2\2\2A\u01b3\3\2\2\2C\u01b6\3\2\2\2E\u01b9\3\2\2\2G\u01bc\3\2\2\2I"+
"?\u01b4\3\2\2\2A\u01b7\3\2\2\2C\u01bb\3\2\2\2E\u01be\3\2\2\2G\u01c1\3"+ "\u01bf\3\2\2\2K\u01c3\3\2\2\2M\u01c7\3\2\2\2O\u01ca\3\2\2\2Q\u01cd\3\2"+
"\2\2\2I\u01c4\3\2\2\2K\u01c7\3\2\2\2M\u01cb\3\2\2\2O\u01cf\3\2\2\2Q\u01d2"+ "\2\2S\u01cf\3\2\2\2U\u01d1\3\2\2\2W\u01d3\3\2\2\2Y\u01d6\3\2\2\2[\u01d8"+
"\3\2\2\2S\u01d5\3\2\2\2U\u01d7\3\2\2\2W\u01d9\3\2\2\2Y\u01db\3\2\2\2["+ "\3\2\2\2]\u01da\3\2\2\2_\u01dc\3\2\2\2a\u01df\3\2\2\2c\u01e2\3\2\2\2e"+
"\u01de\3\2\2\2]\u01e0\3\2\2\2_\u01e2\3\2\2\2a\u01e4\3\2\2\2c\u01e7\3\2"+ "\u01e4\3\2\2\2g\u01e6\3\2\2\2i\u01e9\3\2\2\2k\u01ec\3\2\2\2m\u01ef\3\2"+
"\2\2e\u01ea\3\2\2\2g\u01ec\3\2\2\2i\u01ee\3\2\2\2k\u01f1\3\2\2\2m\u01f4"+ "\2\2o\u01f2\3\2\2\2q\u01f4\3\2\2\2s\u01f6\3\2\2\2u\u01f9\3\2\2\2w\u01fe"+
"\3\2\2\2o\u01f7\3\2\2\2q\u01fa\3\2\2\2s\u01fc\3\2\2\2u\u01fe\3\2\2\2w"+ "\3\2\2\2y\u0202\3\2\2\2{\u0205\3\2\2\2}\u0209\3\2\2\2\177\u020d\3\2\2"+
"\u0201\3\2\2\2y\u0206\3\2\2\2{\u020a\3\2\2\2}\u020d\3\2\2\2\177\u0211"+ "\2\u0081\u020f\3\2\2\2\u0083\u0211\3\2\2\2\u0085\u0214\3\2\2\2\u0087\u0216"+
"\3\2\2\2\u0081\u0215\3\2\2\2\u0083\u0217\3\2\2\2\u0085\u0219\3\2\2\2\u0087"+ "\3\2\2\2\u0089\u021d\3\2\2\2\u008b\u0223\3\2\2\2\u008d\u022c\3\2\2\2\u008f"+
"\u021c\3\2\2\2\u0089\u021e\3\2\2\2\u008b\u0225\3\2\2\2\u008d\u022b\3\2"+ "\u022e\3\2\2\2\u0091\u0230\3\2\2\2\u0093\u0232\3\2\2\2\u0095\u0234\3\2"+
"\2\2\u008f\u0234\3\2\2\2\u0091\u0236\3\2\2\2\u0093\u0238\3\2\2\2\u0095"+ "\2\2\u0097\u0237\3\2\2\2\u0099\u023a\3\2\2\2\u009b\u023d\3\2\2\2\u009d"+
"\u023a\3\2\2\2\u0097\u023c\3\2\2\2\u0099\u023f\3\2\2\2\u009b\u0242\3\2"+ "\u0240\3\2\2\2\u009f\u0243\3\2\2\2\u00a1\u0246\3\2\2\2\u00a3\u0249\3\2"+
"\2\2\u009d\u0245\3\2\2\2\u009f\u0248\3\2\2\2\u00a1\u024b\3\2\2\2\u00a3"+ "\2\2\u00a5\u024c\3\2\2\2\u00a7\u0251\3\2\2\2\u00a9\u0257\3\2\2\2\u00ab"+
"\u024e\3\2\2\2\u00a5\u0251\3\2\2\2\u00a7\u0254\3\2\2\2\u00a9\u0259\3\2"+ "\u025c\3\2\2\2\u00ad\u0260\3\2\2\2\u00af\u0263\3\2\2\2\u00b1\u026a\3\2"+
"\2\2\u00ab\u025f\3\2\2\2\u00ad\u0264\3\2\2\2\u00af\u0268\3\2\2\2\u00b1"+ "\2\2\u00b3\u0270\3\2\2\2\u00b5\u0279\3\2\2\2\u00b7\u027c\3\2\2\2\u00b9"+
"\u026b\3\2\2\2\u00b3\u0272\3\2\2\2\u00b5\u0278\3\2\2\2\u00b7\u0281\3\2"+ "\u0281\3\2\2\2\u00bb\u0287\3\2\2\2\u00bd\u028d\3\2\2\2\u00bf\u0293\3\2"+
"\2\2\u00b9\u0284\3\2\2\2\u00bb\u0289\3\2\2\2\u00bd\u028f\3\2\2\2\u00bf"+ "\2\2\u00c1\u0298\3\2\2\2\u00c3\u029e\3\2\2\2\u00c5\u02a4\3\2\2\2\u00c7"+
"\u0295\3\2\2\2\u00c1\u029b\3\2\2\2\u00c3\u02a0\3\2\2\2\u00c5\u02a6\3\2"+ "\u02aa\3\2\2\2\u00c9\u02b1\3\2\2\2\u00cb\u02b7\3\2\2\2\u00cd\u02be\3\2"+
"\2\2\u00c7\u02ac\3\2\2\2\u00c9\u02b2\3\2\2\2\u00cb\u02b9\3\2\2\2\u00cd"+ "\2\2\u00cf\u02c4\3\2\2\2\u00d1\u02ca\3\2\2\2\u00d3\u02ce\3\2\2\2\u00d5"+
"\u02bf\3\2\2\2\u00cf\u02c6\3\2\2\2\u00d1\u02cc\3\2\2\2\u00d3\u02d2\3\2"+ "\u02d1\3\2\2\2\u00d7\u02d7\3\2\2\2\u00d9\u02de\3\2\2\2\u00db\u02e4\3\2"+
"\2\2\u00d5\u02d6\3\2\2\2\u00d7\u02d9\3\2\2\2\u00d9\u02df\3\2\2\2\u00db"+ "\2\2\u00dd\u02e9\3\2\2\2\u00df\u02f4\3\2\2\2\u00e1\u02fd\3\2\2\2\u00e3"+
"\u02e6\3\2\2\2\u00dd\u02ec\3\2\2\2\u00df\u02f1\3\2\2\2\u00e1\u02fc\3\2"+ "\u0302\3\2\2\2\u00e5\u0306\3\2\2\2\u00e7\u0314\3\2\2\2\u00e9\u0316\3\2"+
"\2\2\u00e3\u0305\3\2\2\2\u00e5\u030a\3\2\2\2\u00e7\u030e\3\2\2\2\u00e9"+ "\2\2\u00eb\u031c\3\2\2\2\u00ed\u0322\3\2\2\2\u00ef\u0324\3\2\2\2\u00f1"+
"\u031c\3\2\2\2\u00eb\u031e\3\2\2\2\u00ed\u0324\3\2\2\2\u00ef\u032a\3\2"+ "\u032d\3\2\2\2\u00f3\u033d\3\2\2\2\u00f5\u033f\3\2\2\2\u00f7\u034a\3\2"+
"\2\2\u00f1\u032c\3\2\2\2\u00f3\u0335\3\2\2\2\u00f5\u0345\3\2\2\2\u00f7"+ "\2\2\u00f9\u0357\3\2\2\2\u00fb\u035f\3\2\2\2\u00fd\u0363\3\2\2\2\u00ff"+
"\u0347\3\2\2\2\u00f9\u0352\3\2\2\2\u00fb\u035f\3\2\2\2\u00fd\u0367\3\2"+ "\u0100\7<\2\2\u0100\4\3\2\2\2\u0101\u0102\7i\2\2\u0102\u0103\7q\2\2\u0103"+
"\2\2\u00ff\u036b\3\2\2\2\u0101\u0102\7<\2\2\u0102\4\3\2\2\2\u0103\u0104"+ "\u0104\7v\2\2\u0104\u0105\7q\2\2\u0105\6\3\2\2\2\u0106\u0107\7\'\2\2\u0107"+
"\7i\2\2\u0104\u0105\7q\2\2\u0105\u0106\7v\2\2\u0106\u0107\7q\2\2\u0107"+ "\u0108\7q\2\2\u0108\u0109\7w\2\2\u0109\u010a\7v\2\2\u010a\u010b\7r\2\2"+
"\6\3\2\2\2\u0108\u0109\7\'\2\2\u0109\u010a\7q\2\2\u010a\u010b\7w\2\2\u010b"+ "\u010b\u010c\7w\2\2\u010c\u010d\7v\2\2\u010d\b\3\2\2\2\u010e\u010f\7\'"+
"\u010c\7v\2\2\u010c\u010d\7r\2\2\u010d\u010e\7w\2\2\u010e\u010f\7v\2\2"+ "\2\2\u010f\u0110\7n\2\2\u0110\u0111\7c\2\2\u0111\u0112\7w\2\2\u0112\u0113"+
"\u010f\b\3\2\2\2\u0110\u0111\7\'\2\2\u0111\u0112\7n\2\2\u0112\u0113\7"+ "\7p\2\2\u0113\u0114\7e\2\2\u0114\u0115\7j\2\2\u0115\u0116\7g\2\2\u0116"+
"c\2\2\u0113\u0114\7w\2\2\u0114\u0115\7p\2\2\u0115\u0116\7e\2\2\u0116\u0117"+ "\u0117\7t\2\2\u0117\n\3\2\2\2\u0118\u0119\7\'\2\2\u0119\u011a\7|\2\2\u011a"+
"\7j\2\2\u0117\u0118\7g\2\2\u0118\u0119\7t\2\2\u0119\n\3\2\2\2\u011a\u011b"+ "\u011b\7g\2\2\u011b\u011c\7t\2\2\u011c\u011d\7q\2\2\u011d\u011e\7r\2\2"+
"\7\'\2\2\u011b\u011c\7|\2\2\u011c\u011d\7g\2\2\u011d\u011e\7t\2\2\u011e"+ "\u011e\u011f\7c\2\2\u011f\u0120\7i\2\2\u0120\u0121\7g\2\2\u0121\f\3\2"+
"\u011f\7q\2\2\u011f\u0120\7r\2\2\u0120\u0121\7c\2\2\u0121\u0122\7i\2\2"+ "\2\2\u0122\u0123\7\'\2\2\u0123\u0124\7|\2\2\u0124\u0125\7r\2\2\u0125\u0126"+
"\u0122\u0123\7g\2\2\u0123\f\3\2\2\2\u0124\u0125\7\'\2\2\u0125\u0126\7"+ "\7t\2\2\u0126\u0127\7g\2\2\u0127\u0128\7u\2\2\u0128\u0129\7g\2\2\u0129"+
"|\2\2\u0126\u0127\7r\2\2\u0127\u0128\7t\2\2\u0128\u0129\7g\2\2\u0129\u012a"+ "\u012a\7t\2\2\u012a\u012b\7x\2\2\u012b\u012c\7g\2\2\u012c\u012d\7f\2\2"+
"\7u\2\2\u012a\u012b\7g\2\2\u012b\u012c\7t\2\2\u012c\u012d\7x\2\2\u012d"+ "\u012d\16\3\2\2\2\u012e\u012f\7\'\2\2\u012f\u0130\7c\2\2\u0130\u0131\7"+
"\u012e\7g\2\2\u012e\u012f\7f\2\2\u012f\16\3\2\2\2\u0130\u0131\7\'\2\2"+ "f\2\2\u0131\u0132\7f\2\2\u0132\u0133\7t\2\2\u0133\u0134\7g\2\2\u0134\u0135"+
"\u0131\u0132\7c\2\2\u0132\u0133\7f\2\2\u0133\u0134\7f\2\2\u0134\u0135"+ "\7u\2\2\u0135\u0136\7u\2\2\u0136\20\3\2\2\2\u0137\u0138\7\'\2\2\u0138"+
"\7t\2\2\u0135\u0136\7g\2\2\u0136\u0137\7u\2\2\u0137\u0138\7u\2\2\u0138"+ "\u0139\7k\2\2\u0139\u013a\7o\2\2\u013a\u013b\7r\2\2\u013b\u013c\7q\2\2"+
"\20\3\2\2\2\u0139\u013a\7\'\2\2\u013a\u013b\7k\2\2\u013b\u013c\7o\2\2"+ "\u013c\u013d\7t\2\2\u013d\u013e\7v\2\2\u013e\22\3\2\2\2\u013f\u0140\7"+
"\u013c\u013d\7r\2\2\u013d\u013e\7q\2\2\u013e\u013f\7t\2\2\u013f\u0140"+ "\'\2\2\u0140\u0141\7d\2\2\u0141\u0142\7t\2\2\u0142\u0143\7g\2\2\u0143"+
"\7v\2\2\u0140\22\3\2\2\2\u0141\u0142\7\'\2\2\u0142\u0143\7d\2\2\u0143"+ "\u0144\7c\2\2\u0144\u0145\7m\2\2\u0145\u0146\7r\2\2\u0146\u0147\7q\2\2"+
"\u0144\7t\2\2\u0144\u0145\7g\2\2\u0145\u0146\7c\2\2\u0146\u0147\7m\2\2"+ "\u0147\u0148\7k\2\2\u0148\u0149\7p\2\2\u0149\u014a\7v\2\2\u014a\24\3\2"+
"\u0147\u0148\7r\2\2\u0148\u0149\7q\2\2\u0149\u014a\7k\2\2\u014a\u014b"+ "\2\2\u014b\u014c\7\'\2\2\u014c\u014d\7c\2\2\u014d\u014e\7u\2\2\u014e\u014f"+
"\7p\2\2\u014b\u014c\7v\2\2\u014c\24\3\2\2\2\u014d\u014e\7\'\2\2\u014e"+ "\7o\2\2\u014f\u0150\7k\2\2\u0150\u0151\7p\2\2\u0151\u0152\7e\2\2\u0152"+
"\u014f\7c\2\2\u014f\u0150\7u\2\2\u0150\u0151\7o\2\2\u0151\u0152\7k\2\2"+ "\u0153\7n\2\2\u0153\u0154\7w\2\2\u0154\u0155\7f\2\2\u0155\u0156\7g\2\2"+
"\u0152\u0153\7p\2\2\u0153\u0154\7e\2\2\u0154\u0155\7n\2\2\u0155\u0156"+ "\u0156\26\3\2\2\2\u0157\u0158\7\'\2\2\u0158\u0159\7c\2\2\u0159\u015a\7"+
"\7w\2\2\u0156\u0157\7f\2\2\u0157\u0158\7g\2\2\u0158\26\3\2\2\2\u0159\u015a"+ "u\2\2\u015a\u015b\7o\2\2\u015b\u015c\7d\2\2\u015c\u015d\7k\2\2\u015d\u015e"+
"\7\'\2\2\u015a\u015b\7c\2\2\u015b\u015c\7u\2\2\u015c\u015d\7o\2\2\u015d"+ "\7p\2\2\u015e\u015f\7c\2\2\u015f\u0160\7t\2\2\u0160\u0161\7{\2\2\u0161"+
"\u015e\7d\2\2\u015e\u015f\7k\2\2\u015f\u0160\7p\2\2\u0160\u0161\7c\2\2"+ "\30\3\2\2\2\u0162\u0163\7\'\2\2\u0163\u0164\7q\2\2\u0164\u0165\7r\2\2"+
"\u0161\u0162\7t\2\2\u0162\u0163\7{\2\2\u0163\30\3\2\2\2\u0164\u0165\7"+ "\u0165\u0166\7v\2\2\u0166\u0167\7k\2\2\u0167\u0168\7q\2\2\u0168\u0169"+
"\'\2\2\u0165\u0166\7q\2\2\u0166\u0167\7r\2\2\u0167\u0168\7v\2\2\u0168"+ "\7p\2\2\u0169\32\3\2\2\2\u016a\u016b\7.\2\2\u016b\34\3\2\2\2\u016c\u016d"+
"\u0169\7k\2\2\u0169\u016a\7q\2\2\u016a\u016b\7p\2\2\u016b\32\3\2\2\2\u016c"+ "\7?\2\2\u016d\36\3\2\2\2\u016e\u016f\7e\2\2\u016f\u0170\7q\2\2\u0170\u0171"+
"\u016d\7.\2\2\u016d\34\3\2\2\2\u016e\u016f\7?\2\2\u016f\36\3\2\2\2\u0170"+ "\7p\2\2\u0171\u0172\7u\2\2\u0172\u0173\7v\2\2\u0173 \3\2\2\2\u0174\u0175"+
"\u0171\7e\2\2\u0171\u0172\7q\2\2\u0172\u0173\7p\2\2\u0173\u0174\7u\2\2"+ "\7u\2\2\u0175\u0176\7v\2\2\u0176\u0177\7t\2\2\u0177\u0178\7w\2\2\u0178"+
"\u0174\u0175\7v\2\2\u0175 \3\2\2\2\u0176\u0177\7u\2\2\u0177\u0178\7v\2"+ "\u0179\7e\2\2\u0179\u017a\7v\2\2\u017a\"\3\2\2\2\u017b\u017c\7}\2\2\u017c"+
"\2\u0178\u0179\7t\2\2\u0179\u017a\7w\2\2\u017a\u017b\7e\2\2\u017b\u017c"+ "$\3\2\2\2\u017d\u017e\7\177\2\2\u017e&\3\2\2\2\u017f\u0180\7w\2\2\u0180"+
"\7v\2\2\u017c\"\3\2\2\2\u017d\u017e\7}\2\2\u017e$\3\2\2\2\u017f\u0180"+ "\u0181\7d\2\2\u0181\u0182\7{\2\2\u0182\u0183\7v\2\2\u0183\u0184\7g\2\2"+
"\7\177\2\2\u0180&\3\2\2\2\u0181\u0182\7w\2\2\u0182\u0183\7d\2\2\u0183"+ "\u0184(\3\2\2\2\u0185\u0186\7d\2\2\u0186\u0187\7{\2\2\u0187\u0188\7v\2"+
"\u0184\7{\2\2\u0184\u0185\7v\2\2\u0185\u0186\7g\2\2\u0186(\3\2\2\2\u0187"+ "\2\u0188\u0189\7g\2\2\u0189*\3\2\2\2\u018a\u018b\7w\2\2\u018b\u018c\7"+
"\u0188\7d\2\2\u0188\u0189\7{\2\2\u0189\u018a\7v\2\2\u018a\u018b\7g\2\2"+ "y\2\2\u018c\u018d\7q\2\2\u018d\u018e\7t\2\2\u018e\u018f\7f\2\2\u018f,"+
"\u018b*\3\2\2\2\u018c\u018d\7w\2\2\u018d\u018e\7y\2\2\u018e\u018f\7q\2"+ "\3\2\2\2\u0190\u0191\7y\2\2\u0191\u0192\7q\2\2\u0192\u0193\7t\2\2\u0193"+
"\2\u018f\u0190\7t\2\2\u0190\u0191\7f\2\2\u0191,\3\2\2\2\u0192\u0193\7"+ "\u0194\7f\2\2\u0194.\3\2\2\2\u0195\u0196\7h\2\2\u0196\u0197\7n\2\2\u0197"+
"y\2\2\u0193\u0194\7q\2\2\u0194\u0195\7t\2\2\u0195\u0196\7f\2\2\u0196."+ "\u0198\7q\2\2\u0198\u0199\7c\2\2\u0199\u019a\7v\2\2\u019a\60\3\2\2\2\u019b"+
"\3\2\2\2\u0197\u0198\7h\2\2\u0198\u0199\7n\2\2\u0199\u019a\7q\2\2\u019a"+ "\u019c\7u\2\2\u019c\u019d\7v\2\2\u019d\u019e\7t\2\2\u019e\62\3\2\2\2\u019f"+
"\u019b\7c\2\2\u019b\u019c\7v\2\2\u019c\60\3\2\2\2\u019d\u019e\7u\2\2\u019e"+ "\u01a0\7]\2\2\u01a0\64\3\2\2\2\u01a1\u01a2\7_\2\2\u01a2\66\3\2\2\2\u01a3"+
"\u019f\7v\2\2\u019f\u01a0\7t\2\2\u01a0\62\3\2\2\2\u01a1\u01a2\7u\2\2\u01a2"+ "\u01a4\7-\2\2\u01a4\u01a5\7?\2\2\u01a58\3\2\2\2\u01a6\u01a7\7/\2\2\u01a7"+
"\u01a3\7v\2\2\u01a3\u01a4\7t\2\2\u01a4\u01a5\7a\2\2\u01a5\u01a6\7u\2\2"+ "\u01a8\7?\2\2\u01a8:\3\2\2\2\u01a9\u01aa\7\61\2\2\u01aa\u01ab\7?\2\2\u01ab"+
"\u01a6\64\3\2\2\2\u01a7\u01a8\7]\2\2\u01a8\66\3\2\2\2\u01a9\u01aa\7_\2"+ "<\3\2\2\2\u01ac\u01ad\7,\2\2\u01ad\u01ae\7?\2\2\u01ae>\3\2\2\2\u01af\u01b0"+
"\2\u01aa8\3\2\2\2\u01ab\u01ac\7-\2\2\u01ac\u01ad\7?\2\2\u01ad:\3\2\2\2"+ "\7,\2\2\u01b0\u01b1\7,\2\2\u01b1\u01b2\7?\2\2\u01b2@\3\2\2\2\u01b3\u01b4"+
"\u01ae\u01af\7/\2\2\u01af\u01b0\7?\2\2\u01b0<\3\2\2\2\u01b1\u01b2\7\61"+ "\7(\2\2\u01b4\u01b5\7?\2\2\u01b5B\3\2\2\2\u01b6\u01b7\7~\2\2\u01b7\u01b8"+
"\2\2\u01b2\u01b3\7?\2\2\u01b3>\3\2\2\2\u01b4\u01b5\7,\2\2\u01b5\u01b6"+ "\7?\2\2\u01b8D\3\2\2\2\u01b9\u01ba\7`\2\2\u01ba\u01bb\7?\2\2\u01bbF\3"+
"\7?\2\2\u01b6@\3\2\2\2\u01b7\u01b8\7,\2\2\u01b8\u01b9\7,\2\2\u01b9\u01ba"+ "\2\2\2\u01bc\u01bd\7\'\2\2\u01bd\u01be\7?\2\2\u01beH\3\2\2\2\u01bf\u01c0"+
"\7?\2\2\u01baB\3\2\2\2\u01bb\u01bc\7(\2\2\u01bc\u01bd\7?\2\2\u01bdD\3"+ "\7>\2\2\u01c0\u01c1\7>\2\2\u01c1\u01c2\7?\2\2\u01c2J\3\2\2\2\u01c3\u01c4"+
"\2\2\2\u01be\u01bf\7~\2\2\u01bf\u01c0\7?\2\2\u01c0F\3\2\2\2\u01c1\u01c2"+ "\7@\2\2\u01c4\u01c5\7@\2\2\u01c5\u01c6\7?\2\2\u01c6L\3\2\2\2\u01c7\u01c8"+
"\7`\2\2\u01c2\u01c3\7?\2\2\u01c3H\3\2\2\2\u01c4\u01c5\7\'\2\2\u01c5\u01c6"+ "\7-\2\2\u01c8\u01c9\7-\2\2\u01c9N\3\2\2\2\u01ca\u01cb\7/\2\2\u01cb\u01cc"+
"\7?\2\2\u01c6J\3\2\2\2\u01c7\u01c8\7>\2\2\u01c8\u01c9\7>\2\2\u01c9\u01ca"+ "\7/\2\2\u01ccP\3\2\2\2\u01cd\u01ce\7-\2\2\u01ceR\3\2\2\2\u01cf\u01d0\7"+
"\7?\2\2\u01caL\3\2\2\2\u01cb\u01cc\7@\2\2\u01cc\u01cd\7@\2\2\u01cd\u01ce"+ "/\2\2\u01d0T\3\2\2\2\u01d1\u01d2\7\u0080\2\2\u01d2V\3\2\2\2\u01d3\u01d4"+
"\7?\2\2\u01ceN\3\2\2\2\u01cf\u01d0\7-\2\2\u01d0\u01d1\7-\2\2\u01d1P\3"+ "\7,\2\2\u01d4\u01d5\7,\2\2\u01d5X\3\2\2\2\u01d6\u01d7\7,\2\2\u01d7Z\3"+
"\2\2\2\u01d2\u01d3\7/\2\2\u01d3\u01d4\7/\2\2\u01d4R\3\2\2\2\u01d5\u01d6"+ "\2\2\2\u01d8\u01d9\7\61\2\2\u01d9\\\3\2\2\2\u01da\u01db\7\'\2\2\u01db"+
"\7-\2\2\u01d6T\3\2\2\2\u01d7\u01d8\7/\2\2\u01d8V\3\2\2\2\u01d9\u01da\7"+ "^\3\2\2\2\u01dc\u01dd\7>\2\2\u01dd\u01de\7>\2\2\u01de`\3\2\2\2\u01df\u01e0"+
"\u0080\2\2\u01daX\3\2\2\2\u01db\u01dc\7,\2\2\u01dc\u01dd\7,\2\2\u01dd"+ "\7@\2\2\u01e0\u01e1\7@\2\2\u01e1b\3\2\2\2\u01e2\u01e3\7>\2\2\u01e3d\3"+
"Z\3\2\2\2\u01de\u01df\7,\2\2\u01df\\\3\2\2\2\u01e0\u01e1\7\61\2\2\u01e1"+ "\2\2\2\u01e4\u01e5\7@\2\2\u01e5f\3\2\2\2\u01e6\u01e7\7>\2\2\u01e7\u01e8"+
"^\3\2\2\2\u01e2\u01e3\7\'\2\2\u01e3`\3\2\2\2\u01e4\u01e5\7>\2\2\u01e5"+ "\7?\2\2\u01e8h\3\2\2\2\u01e9\u01ea\7@\2\2\u01ea\u01eb\7?\2\2\u01ebj\3"+
"\u01e6\7>\2\2\u01e6b\3\2\2\2\u01e7\u01e8\7@\2\2\u01e8\u01e9\7@\2\2\u01e9"+ "\2\2\2\u01ec\u01ed\7?\2\2\u01ed\u01ee\7?\2\2\u01eel\3\2\2\2\u01ef\u01f0"+
"d\3\2\2\2\u01ea\u01eb\7>\2\2\u01ebf\3\2\2\2\u01ec\u01ed\7@\2\2\u01edh"+ "\7#\2\2\u01f0\u01f1\7?\2\2\u01f1n\3\2\2\2\u01f2\u01f3\7`\2\2\u01f3p\3"+
"\3\2\2\2\u01ee\u01ef\7>\2\2\u01ef\u01f0\7?\2\2\u01f0j\3\2\2\2\u01f1\u01f2"+ "\2\2\2\u01f4\u01f5\7~\2\2\u01f5r\3\2\2\2\u01f6\u01f7\7v\2\2\u01f7\u01f8"+
"\7@\2\2\u01f2\u01f3\7?\2\2\u01f3l\3\2\2\2\u01f4\u01f5\7?\2\2\u01f5\u01f6"+ "\7q\2\2\u01f8t\3\2\2\2\u01f9\u01fa\7u\2\2\u01fa\u01fb\7v\2\2\u01fb\u01fc"+
"\7?\2\2\u01f6n\3\2\2\2\u01f7\u01f8\7#\2\2\u01f8\u01f9\7?\2\2\u01f9p\3"+ "\7g\2\2\u01fc\u01fd\7r\2\2\u01fdv\3\2\2\2\u01fe\u01ff\7c\2\2\u01ff\u0200"+
"\2\2\2\u01fa\u01fb\7`\2\2\u01fbr\3\2\2\2\u01fc\u01fd\7~\2\2\u01fdt\3\2"+ "\7p\2\2\u0200\u0201\7f\2\2\u0201x\3\2\2\2\u0202\u0203\7q\2\2\u0203\u0204"+
"\2\2\u01fe\u01ff\7v\2\2\u01ff\u0200\7q\2\2\u0200v\3\2\2\2\u0201\u0202"+ "\7t\2\2\u0204z\3\2\2\2\u0205\u0206\7z\2\2\u0206\u0207\7q\2\2\u0207\u0208"+
"\7u\2\2\u0202\u0203\7v\2\2\u0203\u0204\7g\2\2\u0204\u0205\7r\2\2\u0205"+ "\7t\2\2\u0208|\3\2\2\2\u0209\u020a\7p\2\2\u020a\u020b\7q\2\2\u020b\u020c"+
"x\3\2\2\2\u0206\u0207\7c\2\2\u0207\u0208\7p\2\2\u0208\u0209\7f\2\2\u0209"+ "\7v\2\2\u020c~\3\2\2\2\u020d\u020e\7*\2\2\u020e\u0080\3\2\2\2\u020f\u0210"+
"z\3\2\2\2\u020a\u020b\7q\2\2\u020b\u020c\7t\2\2\u020c|\3\2\2\2\u020d\u020e"+ "\7+\2\2\u0210\u0082\3\2\2\2\u0211\u0212\7c\2\2\u0212\u0213\7u\2\2\u0213"+
"\7z\2\2\u020e\u020f\7q\2\2\u020f\u0210\7t\2\2\u0210~\3\2\2\2\u0211\u0212"+ "\u0084\3\2\2\2\u0214\u0215\7B\2\2\u0215\u0086\3\2\2\2\u0216\u0217\7t\2"+
"\7p\2\2\u0212\u0213\7q\2\2\u0213\u0214\7v\2\2\u0214\u0080\3\2\2\2\u0215"+ "\2\u0217\u0218\7g\2\2\u0218\u0219\7v\2\2\u0219\u021a\7w\2\2\u021a\u021b"+
"\u0216\7*\2\2\u0216\u0082\3\2\2\2\u0217\u0218\7+\2\2\u0218\u0084\3\2\2"+ "\7t\2\2\u021b\u021c\7p\2\2\u021c\u0088\3\2\2\2\u021d\u021e\7d\2\2\u021e"+
"\2\u0219\u021a\7c\2\2\u021a\u021b\7u\2\2\u021b\u0086\3\2\2\2\u021c\u021d"+ "\u021f\7t\2\2\u021f\u0220\7g\2\2\u0220\u0221\7c\2\2\u0221\u0222\7m\2\2"+
"\7B\2\2\u021d\u0088\3\2\2\2\u021e\u021f\7t\2\2\u021f\u0220\7g\2\2\u0220"+ "\u0222\u008a\3\2\2\2\u0223\u0224\7e\2\2\u0224\u0225\7q\2\2\u0225\u0226"+
"\u0221\7v\2\2\u0221\u0222\7w\2\2\u0222\u0223\7t\2\2\u0223\u0224\7p\2\2"+ "\7p\2\2\u0226\u0227\7v\2\2\u0227\u0228\7k\2\2\u0228\u0229\7p\2\2\u0229"+
"\u0224\u008a\3\2\2\2\u0225\u0226\7d\2\2\u0226\u0227\7t\2\2\u0227\u0228"+ "\u022a\7w\2\2\u022a\u022b\7g\2\2\u022b\u008c\3\2\2\2\u022c\u022d\7\60"+
"\7g\2\2\u0228\u0229\7c\2\2\u0229\u022a\7m\2\2\u022a\u008c\3\2\2\2\u022b"+ "\2\2\u022d\u008e\3\2\2\2\u022e\u022f\7C\2\2\u022f\u0090\3\2\2\2\u0230"+
"\u022c\7e\2\2\u022c\u022d\7q\2\2\u022d\u022e\7p\2\2\u022e\u022f\7v\2\2"+ "\u0231\7Z\2\2\u0231\u0092\3\2\2\2\u0232\u0233\7[\2\2\u0233\u0094\3\2\2"+
"\u022f\u0230\7k\2\2\u0230\u0231\7p\2\2\u0231\u0232\7w\2\2\u0232\u0233"+ "\2\u0234\u0235\7C\2\2\u0235\u0236\7Z\2\2\u0236\u0096\3\2\2\2\u0237\u0238"+
"\7g\2\2\u0233\u008e\3\2\2\2\u0234\u0235\7\60\2\2\u0235\u0090\3\2\2\2\u0236"+ "\7C\2\2\u0238\u0239\7[\2\2\u0239\u0098\3\2\2\2\u023a\u023b\7Z\2\2\u023b"+
"\u0237\7C\2\2\u0237\u0092\3\2\2\2\u0238\u0239\7Z\2\2\u0239\u0094\3\2\2"+ "\u023c\7[\2\2\u023c\u009a\3\2\2\2\u023d\u023e\7R\2\2\u023e\u023f\7e\2"+
"\2\u023a\u023b\7[\2\2\u023b\u0096\3\2\2\2\u023c\u023d\7C\2\2\u023d\u023e"+ "\2\u023f\u009c\3\2\2\2\u0240\u0241\7R\2\2\u0241\u0242\7|\2\2\u0242\u009e"+
"\7Z\2\2\u023e\u0098\3\2\2\2\u023f\u0240\7C\2\2\u0240\u0241\7[\2\2\u0241"+ "\3\2\2\2\u0243\u0244\7R\2\2\u0244\u0245\7p\2\2\u0245\u00a0\3\2\2\2\u0246"+
"\u009a\3\2\2\2\u0242\u0243\7Z\2\2\u0243\u0244\7[\2\2\u0244\u009c\3\2\2"+ "\u0247\7R\2\2\u0247\u0248\7x\2\2\u0248\u00a2\3\2\2\2\u0249\u024a\7\60"+
"\2\u0245\u0246\7R\2\2\u0246\u0247\7e\2\2\u0247\u009e\3\2\2\2\u0248\u0249"+ "\2\2\u024a\u024b\7y\2\2\u024b\u00a4\3\2\2\2\u024c\u024d\7v\2\2\u024d\u024e"+
"\7R\2\2\u0249\u024a\7|\2\2\u024a\u00a0\3\2\2\2\u024b\u024c\7R\2\2\u024c"+ "\7t\2\2\u024e\u024f\7w\2\2\u024f\u0250\7g\2\2\u0250\u00a6\3\2\2\2\u0251"+
"\u024d\7p\2\2\u024d\u00a2\3\2\2\2\u024e\u024f\7R\2\2\u024f\u0250\7x\2"+ "\u0252\7h\2\2\u0252\u0253\7c\2\2\u0253\u0254\7n\2\2\u0254\u0255\7u\2\2"+
"\2\u0250\u00a4\3\2\2\2\u0251\u0252\7\60\2\2\u0252\u0253\7y\2\2\u0253\u00a6"+ "\u0255\u0256\7g\2\2\u0256\u00a8\3\2\2\2\u0257\u0258\7\'\2\2\u0258\u0259"+
"\3\2\2\2\u0254\u0255\7v\2\2\u0255\u0256\7t\2\2\u0256\u0257\7w\2\2\u0257"+ "\7c\2\2\u0259\u025a\7u\2\2\u025a\u025b\7o\2\2\u025b\u00aa\3\2\2\2\u025c"+
"\u0258\7g\2\2\u0258\u00a8\3\2\2\2\u0259\u025a\7h\2\2\u025a\u025b\7c\2"+ "\u025d\7u\2\2\u025d\u025e\7w\2\2\u025e\u025f\7d\2\2\u025f\u00ac\3\2\2"+
"\2\u025b\u025c\7n\2\2\u025c\u025d\7u\2\2\u025d\u025e\7g\2\2\u025e\u00aa"+ "\2\u0260\u0261\7/\2\2\u0261\u0262\7@\2\2\u0262\u00ae\3\2\2\2\u0263\u0264"+
"\3\2\2\2\u025f\u0260\7\'\2\2\u0260\u0261\7c\2\2\u0261\u0262\7u\2\2\u0262"+ "\7c\2\2\u0264\u0265\7u\2\2\u0265\u0266\7o\2\2\u0266\u0267\7u\2\2\u0267"+
"\u0263\7o\2\2\u0263\u00ac\3\2\2\2\u0264\u0265\7u\2\2\u0265\u0266\7w\2"+ "\u0268\7w\2\2\u0268\u0269\7d\2\2\u0269\u00b0\3\2\2\2\u026a\u026b\7u\2"+
"\2\u0266\u0267\7d\2\2\u0267\u00ae\3\2\2\2\u0268\u0269\7/\2\2\u0269\u026a"+ "\2\u026b\u026c\7v\2\2\u026c\u026d\7c\2\2\u026d\u026e\7e\2\2\u026e\u026f"+
"\7@\2\2\u026a\u00b0\3\2\2\2\u026b\u026c\7c\2\2\u026c\u026d\7u\2\2\u026d"+ "\7m\2\2\u026f\u00b2\3\2\2\2\u0270\u0271\7e\2\2\u0271\u0272\7n\2\2\u0272"+
"\u026e\7o\2\2\u026e\u026f\7u\2\2\u026f\u0270\7w\2\2\u0270\u0271\7d\2\2"+ "\u0273\7q\2\2\u0273\u0274\7d\2\2\u0274\u0275\7d\2\2\u0275\u0276\7g\2\2"+
"\u0271\u00b2\3\2\2\2\u0272\u0273\7u\2\2\u0273\u0274\7v\2\2\u0274\u0275"+ "\u0276\u0277\7t\2\2\u0277\u0278\7u\2\2\u0278\u00b4\3\2\2\2\u0279\u027a"+
"\7c\2\2\u0275\u0276\7e\2\2\u0276\u0277\7m\2\2\u0277\u00b4\3\2\2\2\u0278"+ "\7k\2\2\u027a\u027b\7h\2\2\u027b\u00b6\3\2\2\2\u027c\u027d\7g\2\2\u027d"+
"\u0279\7e\2\2\u0279\u027a\7n\2\2\u027a\u027b\7q\2\2\u027b\u027c\7d\2\2"+ "\u027e\7n\2\2\u027e\u027f\7u\2\2\u027f\u0280\7g\2\2\u0280\u00b8\3\2\2"+
"\u027c\u027d\7d\2\2\u027d\u027e\7g\2\2\u027e\u027f\7t\2\2\u027f\u0280"+ "\2\u0281\u0282\7k\2\2\u0282\u0283\7h\2\2\u0283\u0284\7a\2\2\u0284\u0285"+
"\7u\2\2\u0280\u00b6\3\2\2\2\u0281\u0282\7k\2\2\u0282\u0283\7h\2\2\u0283"+ "\7e\2\2\u0285\u0286\7u\2\2\u0286\u00ba\3\2\2\2\u0287\u0288\7k\2\2\u0288"+
"\u00b8\3\2\2\2\u0284\u0285\7g\2\2\u0285\u0286\7n\2\2\u0286\u0287\7u\2"+ "\u0289\7h\2\2\u0289\u028a\7a\2\2\u028a\u028b\7e\2\2\u028b\u028c\7e\2\2"+
"\2\u0287\u0288\7g\2\2\u0288\u00ba\3\2\2\2\u0289\u028a\7k\2\2\u028a\u028b"+ "\u028c\u00bc\3\2\2\2\u028d\u028e\7k\2\2\u028e\u028f\7h\2\2\u028f\u0290"+
"\7h\2\2\u028b\u028c\7a\2\2\u028c\u028d\7e\2\2\u028d\u028e\7u\2\2\u028e"+ "\7a\2\2\u0290\u0291\7g\2\2\u0291\u0292\7s\2\2\u0292\u00be\3\2\2\2\u0293"+
"\u00bc\3\2\2\2\u028f\u0290\7k\2\2\u0290\u0291\7h\2\2\u0291\u0292\7a\2"+ "\u0294\7k\2\2\u0294\u0295\7h\2\2\u0295\u0296\7a\2\2\u0296\u0297\7|\2\2"+
"\2\u0292\u0293\7e\2\2\u0293\u0294\7e\2\2\u0294\u00be\3\2\2\2\u0295\u0296"+ "\u0297\u00c0\3\2\2\2\u0298\u0299\7k\2\2\u0299\u029a\7h\2\2\u029a\u029b"+
"\7k\2\2\u0296\u0297\7h\2\2\u0297\u0298\7a\2\2\u0298\u0299\7g\2\2\u0299"+ "\7a\2\2\u029b\u029c\7p\2\2\u029c\u029d\7g\2\2\u029d\u00c2\3\2\2\2\u029e"+
"\u029a\7s\2\2\u029a\u00c0\3\2\2\2\u029b\u029c\7k\2\2\u029c\u029d\7h\2"+ "\u029f\7k\2\2\u029f\u02a0\7h\2\2\u02a0\u02a1\7a\2\2\u02a1\u02a2\7p\2\2"+
"\2\u029d\u029e\7a\2\2\u029e\u029f\7|\2\2\u029f\u00c2\3\2\2\2\u02a0\u02a1"+ "\u02a2\u02a3\7|\2\2\u02a3\u00c4\3\2\2\2\u02a4\u02a5\7k\2\2\u02a5\u02a6"+
"\7k\2\2\u02a1\u02a2\7h\2\2\u02a2\u02a3\7a\2\2\u02a3\u02a4\7p\2\2\u02a4"+ "\7h\2\2\u02a6\u02a7\7a\2\2\u02a7\u02a8\7r\2\2\u02a8\u02a9\7n\2\2\u02a9"+
"\u02a5\7g\2\2\u02a5\u00c4\3\2\2\2\u02a6\u02a7\7k\2\2\u02a7\u02a8\7h\2"+ "\u00c6\3\2\2\2\u02aa\u02ab\7k\2\2\u02ab\u02ac\7h\2\2\u02ac\u02ad\7a\2"+
"\2\u02a8\u02a9\7a\2\2\u02a9\u02aa\7p\2\2\u02aa\u02ab\7|\2\2\u02ab\u00c6"+ "\2\u02ad\u02ae\7r\2\2\u02ae\u02af\7q\2\2\u02af\u02b0\7u\2\2\u02b0\u00c8"+
"\3\2\2\2\u02ac\u02ad\7k\2\2\u02ad\u02ae\7h\2\2\u02ae\u02af\7a\2\2\u02af"+ "\3\2\2\2\u02b1\u02b2\7k\2\2\u02b2\u02b3\7h\2\2\u02b3\u02b4\7a\2\2\u02b4"+
"\u02b0\7r\2\2\u02b0\u02b1\7n\2\2\u02b1\u00c8\3\2\2\2\u02b2\u02b3\7k\2"+ "\u02b5\7o\2\2\u02b5\u02b6\7k\2\2\u02b6\u00ca\3\2\2\2\u02b7\u02b8\7k\2"+
"\2\u02b3\u02b4\7h\2\2\u02b4\u02b5\7a\2\2\u02b5\u02b6\7r\2\2\u02b6\u02b7"+ "\2\u02b8\u02b9\7h\2\2\u02b9\u02ba\7a\2\2\u02ba\u02bb\7p\2\2\u02bb\u02bc"+
"\7q\2\2\u02b7\u02b8\7u\2\2\u02b8\u00ca\3\2\2\2\u02b9\u02ba\7k\2\2\u02ba"+ "\7g\2\2\u02bc\u02bd\7i\2\2\u02bd\u00cc\3\2\2\2\u02be\u02bf\7k\2\2\u02bf"+
"\u02bb\7h\2\2\u02bb\u02bc\7a\2\2\u02bc\u02bd\7o\2\2\u02bd\u02be\7k\2\2"+ "\u02c0\7h\2\2\u02c0\u02c1\7a\2\2\u02c1\u02c2\7x\2\2\u02c2\u02c3\7u\2\2"+
"\u02be\u00cc\3\2\2\2\u02bf\u02c0\7k\2\2\u02c0\u02c1\7h\2\2\u02c1\u02c2"+ "\u02c3\u00ce\3\2\2\2\u02c4\u02c5\7k\2\2\u02c5\u02c6\7h\2\2\u02c6\u02c7"+
"\7a\2\2\u02c2\u02c3\7p\2\2\u02c3\u02c4\7g\2\2\u02c4\u02c5\7i\2\2\u02c5"+ "\7a\2\2\u02c7\u02c8\7x\2\2\u02c8\u02c9\7e\2\2\u02c9\u00d0\3\2\2\2\u02ca"+
"\u00ce\3\2\2\2\u02c6\u02c7\7k\2\2\u02c7\u02c8\7h\2\2\u02c8\u02c9\7a\2"+ "\u02cb\7h\2\2\u02cb\u02cc\7q\2\2\u02cc\u02cd\7t\2\2\u02cd\u00d2\3\2\2"+
"\2\u02c9\u02ca\7x\2\2\u02ca\u02cb\7u\2\2\u02cb\u00d0\3\2\2\2\u02cc\u02cd"+ "\2\u02ce\u02cf\7k\2\2\u02cf\u02d0\7p\2\2\u02d0\u00d4\3\2\2\2\u02d1\u02d2"+
"\7k\2\2\u02cd\u02ce\7h\2\2\u02ce\u02cf\7a\2\2\u02cf\u02d0\7x\2\2\u02d0"+ "\7y\2\2\u02d2\u02d3\7j\2\2\u02d3\u02d4\7k\2\2\u02d4\u02d5\7n\2\2\u02d5"+
"\u02d1\7e\2\2\u02d1\u00d2\3\2\2\2\u02d2\u02d3\7h\2\2\u02d3\u02d4\7q\2"+ "\u02d6\7g\2\2\u02d6\u00d6\3\2\2\2\u02d7\u02d8\7t\2\2\u02d8\u02d9\7g\2"+
"\2\u02d4\u02d5\7t\2\2\u02d5\u00d4\3\2\2\2\u02d6\u02d7\7k\2\2\u02d7\u02d8"+ "\2\u02d9\u02da\7r\2\2\u02da\u02db\7g\2\2\u02db\u02dc\7c\2\2\u02dc\u02dd"+
"\7p\2\2\u02d8\u00d6\3\2\2\2\u02d9\u02da\7y\2\2\u02da\u02db\7j\2\2\u02db"+ "\7v\2\2\u02dd\u00d8\3\2\2\2\u02de\u02df\7w\2\2\u02df\u02e0\7p\2\2\u02e0"+
"\u02dc\7k\2\2\u02dc\u02dd\7n\2\2\u02dd\u02de\7g\2\2\u02de\u00d8\3\2\2"+ "\u02e1\7v\2\2\u02e1\u02e2\7k\2\2\u02e2\u02e3\7n\2\2\u02e3\u00da\3\2\2"+
"\2\u02df\u02e0\7t\2\2\u02e0\u02e1\7g\2\2\u02e1\u02e2\7r\2\2\u02e2\u02e3"+ "\2\u02e4\u02e5\7y\2\2\u02e5\u02e6\7j\2\2\u02e6\u02e7\7g\2\2\u02e7\u02e8"+
"\7g\2\2\u02e3\u02e4\7c\2\2\u02e4\u02e5\7v\2\2\u02e5\u00da\3\2\2\2\u02e6"+ "\7p\2\2\u02e8\u00dc\3\2\2\2\u02e9\u02ed\t\2\2\2\u02ea\u02ec\t\3\2\2\u02eb"+
"\u02e7\7w\2\2\u02e7\u02e8\7p\2\2\u02e8\u02e9\7v\2\2\u02e9\u02ea\7k\2\2"+ "\u02ea\3\2\2\2\u02ec\u02ef\3\2\2\2\u02ed\u02eb\3\2\2\2\u02ed\u02ee\3\2"+
"\u02ea\u02eb\7n\2\2\u02eb\u00dc\3\2\2\2\u02ec\u02ed\7y\2\2\u02ed\u02ee"+ "\2\2\u02ee\u02f0\3\2\2\2\u02ef\u02ed\3\2\2\2\u02f0\u02f1\5\u00dfp\2\u02f1"+
"\7j\2\2\u02ee\u02ef\7g\2\2\u02ef\u02f0\7p\2\2\u02f0\u00de\3\2\2\2\u02f1"+ "\u02f2\3\2\2\2\u02f2\u02f3\bo\2\2\u02f3\u00de\3\2\2\2\u02f4\u02f8\7=\2"+
"\u02f5\t\2\2\2\u02f2\u02f4\t\3\2\2\u02f3\u02f2\3\2\2\2\u02f4\u02f7\3\2"+ "\2\u02f5\u02f7\n\2\2\2\u02f6\u02f5\3\2\2\2\u02f7\u02fa\3\2\2\2\u02f8\u02f6"+
"\2\2\u02f5\u02f3\3\2\2\2\u02f5\u02f6\3\2\2\2\u02f6\u02f8\3\2\2\2\u02f7"+ "\3\2\2\2\u02f8\u02f9\3\2\2\2\u02f9\u02fb\3\2\2\2\u02fa\u02f8\3\2\2\2\u02fb"+
"\u02f5\3\2\2\2\u02f8\u02f9\5\u00e1q\2\u02f9\u02fa\3\2\2\2\u02fa\u02fb"+ "\u02fc\bp\2\2\u02fc\u00e0\3\2\2\2\u02fd\u02fe\t\3\2\2\u02fe\u02ff\3\2"+
"\bp\2\2\u02fb\u00e0\3\2\2\2\u02fc\u0300\7=\2\2\u02fd\u02ff\n\2\2\2\u02fe"+ "\2\2\u02ff\u0300\bq\3\2\u0300\u00e2\3\2\2\2\u0301\u0303\t\2\2\2\u0302"+
"\u02fd\3\2\2\2\u02ff\u0302\3\2\2\2\u0300\u02fe\3\2\2\2\u0300\u0301\3\2"+ "\u0301\3\2\2\2\u0303\u0304\3\2\2\2\u0304\u0302\3\2\2\2\u0304\u0305\3\2"+
"\2\2\u0301\u0303\3\2\2\2\u0302\u0300\3\2\2\2\u0303\u0304\bq\2\2\u0304"+ "\2\2\u0305\u00e4\3\2\2\2\u0306\u030a\t\4\2\2\u0307\u0309\t\5\2\2\u0308"+
"\u00e2\3\2\2\2\u0305\u0306\t\3\2\2\u0306\u0307\3\2\2\2\u0307\u0308\br"+ "\u0307\3\2\2\2\u0309\u030c\3\2\2\2\u030a\u0308\3\2\2\2\u030a\u030b\3\2"+
"\3\2\u0308\u00e4\3\2\2\2\u0309\u030b\t\2\2\2\u030a\u0309\3\2\2\2\u030b"+ "\2\2\u030b\u00e6\3\2\2\2\u030c\u030a\3\2\2\2\u030d\u0315\4\62;\2\u030e"+
"\u030c\3\2\2\2\u030c\u030a\3\2\2\2\u030c\u030d\3\2\2\2\u030d\u00e6\3\2"+ "\u0310\4\63;\2\u030f\u0311\4\62;\2\u0310\u030f\3\2\2\2\u0311\u0312\3\2"+
"\2\2\u030e\u0312\t\4\2\2\u030f\u0311\t\5\2\2\u0310\u030f\3\2\2\2\u0311"+ "\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u0315\3\2\2\2\u0314"+
"\u0314\3\2\2\2\u0312\u0310\3\2\2\2\u0312\u0313\3\2\2\2\u0313\u00e8\3\2"+ "\u030d\3\2\2\2\u0314\u030e\3\2\2\2\u0315\u00e8\3\2\2\2\u0316\u0318\7&"+
"\2\2\u0314\u0312\3\2\2\2\u0315\u031d\4\62;\2\u0316\u0318\4\63;\2\u0317"+ "\2\2\u0317\u0319\t\6\2\2\u0318\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a"+
"\u0319\4\62;\2\u0318\u0317\3\2\2\2\u0319\u031a\3\2\2\2\u031a\u0318\3\2"+ "\u0318\3\2\2\2\u031a\u031b\3\2\2\2\u031b\u00ea\3\2\2\2\u031c\u031e\7\'"+
"\2\2\u031a\u031b\3\2\2\2\u031b\u031d\3\2\2\2\u031c\u0315\3\2\2\2\u031c"+ "\2\2\u031d\u031f\4\62\63\2\u031e\u031d\3\2\2\2\u031f\u0320\3\2\2\2\u0320"+
"\u0316\3\2\2\2\u031d\u00ea\3\2\2\2\u031e\u0320\7&\2\2\u031f\u0321\t\6"+ "\u031e\3\2\2\2\u0320\u0321\3\2\2\2\u0321\u00ec\3\2\2\2\u0322\u0323\7("+
"\2\2\u0320\u031f\3\2\2\2\u0321\u0322\3\2\2\2\u0322\u0320\3\2\2\2\u0322"+ "\2\2\u0323\u00ee\3\2\2\2\u0324\u032a\5\u00f1y\2\u0325\u0327\t\7\2\2\u0326"+
"\u0323\3\2\2\2\u0323\u00ec\3\2\2\2\u0324\u0326\7\'\2\2\u0325\u0327\4\62"+ "\u0328\t\b\2\2\u0327\u0326\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0329\3\2"+
"\63\2\u0326\u0325\3\2\2\2\u0327\u0328\3\2\2\2\u0328\u0326\3\2\2\2\u0328"+ "\2\2\u0329\u032b\5\u00f1y\2\u032a\u0325\3\2\2\2\u032a\u032b\3\2\2\2\u032b"+
"\u0329\3\2\2\2\u0329\u00ee\3\2\2\2\u032a\u032b\7(\2\2\u032b\u00f0\3\2"+ "\u00f0\3\2\2\2\u032c\u032e\4\62;\2\u032d\u032c\3\2\2\2\u032e\u032f\3\2"+
"\2\2\u032c\u0332\5\u00f3z\2\u032d\u032f\t\7\2\2\u032e\u0330\t\b\2\2\u032f"+ "\2\2\u032f\u032d\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0337\3\2\2\2\u0331"+
"\u032e\3\2\2\2\u032f\u0330\3\2\2\2\u0330\u0331\3\2\2\2\u0331\u0333\5\u00f3"+ "\u0333\7\60\2\2\u0332\u0334\4\62;\2\u0333\u0332\3\2\2\2\u0334\u0335\3"+
"z\2\u0332\u032d\3\2\2\2\u0332\u0333\3\2\2\2\u0333\u00f2\3\2\2\2\u0334"+ "\2\2\2\u0335\u0333\3\2\2\2\u0335\u0336\3\2\2\2\u0336\u0338\3\2\2\2\u0337"+
"\u0336\4\62;\2\u0335\u0334\3\2\2\2\u0336\u0337\3\2\2\2\u0337\u0335\3\2"+ "\u0331\3\2\2\2\u0337\u0338\3\2\2\2\u0338\u00f2\3\2\2\2\u0339\u033a\7^"+
"\2\2\u0337\u0338\3\2\2\2\u0338\u033f\3\2\2\2\u0339\u033b\7\60\2\2\u033a"+ "\2\2\u033a\u033e\13\2\2\2\u033b\u033c\7^\2\2\u033c\u033e\5\u00e3r\2\u033d"+
"\u033c\4\62;\2\u033b\u033a\3\2\2\2\u033c\u033d\3\2\2\2\u033d\u033b\3\2"+ "\u0339\3\2\2\2\u033d\u033b\3\2\2\2\u033e\u00f4\3\2\2\2\u033f\u0344\7$"+
"\2\2\u033d\u033e\3\2\2\2\u033e\u0340\3\2\2\2\u033f\u0339\3\2\2\2\u033f"+ "\2\2\u0340\u0343\5\u00f3z\2\u0341\u0343\n\t\2\2\u0342\u0340\3\2\2\2\u0342"+
"\u0340\3\2\2\2\u0340\u00f4\3\2\2\2\u0341\u0342\7^\2\2\u0342\u0346\13\2"+ "\u0341\3\2\2\2\u0343\u0346\3\2\2\2\u0344\u0342\3\2\2\2\u0344\u0345\3\2"+
"\2\2\u0343\u0344\7^\2\2\u0344\u0346\5\u00e5s\2\u0345\u0341\3\2\2\2\u0345"+ "\2\2\u0345\u0347\3\2\2\2\u0346\u0344\3\2\2\2\u0347\u0348\7$\2\2\u0348"+
"\u0343\3\2\2\2\u0346\u00f6\3\2\2\2\u0347\u034c\7$\2\2\u0348\u034b\5\u00f5"+ "\u0349\b{\4\2\u0349\u00f6\3\2\2\2\u034a\u034b\7}\2\2\u034b\u034c\7}\2"+
"{\2\u0349\u034b\n\t\2\2\u034a\u0348\3\2\2\2\u034a\u0349\3\2\2\2\u034b"+ "\2\u034c\u034e\3\2\2\2\u034d\u034f\13\2\2\2\u034e\u034d\3\2\2\2\u034f"+
"\u034e\3\2\2\2\u034c\u034a\3\2\2\2\u034c\u034d\3\2\2\2\u034d\u034f\3\2"+ "\u0350\3\2\2\2\u0350\u0351\3\2\2\2\u0350\u034e\3\2\2\2\u0351\u0352\3\2"+
"\2\2\u034e\u034c\3\2\2\2\u034f\u0350\7$\2\2\u0350\u0351\b|\4\2\u0351\u00f8"+ "\2\2\u0352\u0353\7\177\2\2\u0353\u0354\7\177\2\2\u0354\u0355\3\2\2\2\u0355"+
"\3\2\2\2\u0352\u0353\7}\2\2\u0353\u0354\7}\2\2\u0354\u0356\3\2\2\2\u0355"+ "\u0356\b|\5\2\u0356\u00f8\3\2\2\2\u0357\u035a\7)\2\2\u0358\u035b\5\u00f3"+
"\u0357\13\2\2\2\u0356\u0355\3\2\2\2\u0357\u0358\3\2\2\2\u0358\u0359\3"+ "z\2\u0359\u035b\n\t\2\2\u035a\u0358\3\2\2\2\u035a\u0359\3\2\2\2\u035b"+
"\2\2\2\u0358\u0356\3\2\2\2\u0359\u035a\3\2\2\2\u035a\u035b\7\177\2\2\u035b"+ "\u035c\3\2\2\2\u035c\u035d\7)\2\2\u035d\u035e\b}\6\2\u035e\u00fa\3\2\2"+
"\u035c\7\177\2\2\u035c\u035d\3\2\2\2\u035d\u035e\b}\5\2\u035e\u00fa\3"+ "\2\u035f\u0360\7B\2\2\u0360\u0361\7|\2\2\u0361\u0362\7r\2\2\u0362\u00fc"+
"\2\2\2\u035f\u0362\7)\2\2\u0360\u0363\5\u00f5{\2\u0361\u0363\n\t\2\2\u0362"+ "\3\2\2\2\u0363\u0364\7]\2\2\u0364\u0365\7_\2\2\u0365\u00fe\3\2\2\2\26"+
"\u0360\3\2\2\2\u0362\u0361\3\2\2\2\u0363\u0364\3\2\2\2\u0364\u0365\7)"+ "\2\u02ed\u02f8\u0304\u030a\u0312\u0314\u0318\u031a\u0320\u0327\u032a\u032f"+
"\2\2\u0365\u0366\b~\6\2\u0366\u00fc\3\2\2\2\u0367\u0368\7B\2\2\u0368\u0369"+ "\u0335\u0337\u033d\u0342\u0344\u0350\u035a\7\2\3\2\b\2\2\3{\2\3|\3\3}"+
"\7|\2\2\u0369\u036a\7r\2\2\u036a\u00fe\3\2\2\2\u036b\u036c\7]\2\2\u036c"+ "\4";
"\u036d\7_\2\2\u036d\u0100\3\2\2\2\26\2\u02f5\u0300\u030c\u0312\u031a\u031c"+
"\u0320\u0322\u0328\u032f\u0332\u0337\u033d\u033f\u0345\u034a\u034c\u0358"+
"\u0362\7\2\3\2\b\2\2\3|\2\3}\3\3~\4";
public static final ATN _ATN = public static final ATN _ATN =
new ATNDeserializer().deserialize(_serializedATN.toCharArray()); new ATNDeserializer().deserialize(_serializedATN.toCharArray());
static { static {

616
parser/src/prog8/parser/prog8Parser.java
View File

File diff suppressed because it is too large Load Diff